[转]给SSD（固态硬盘）编程

骑猪看日落 2022-08-22 12:27 659阅读 0赞

# 给SSD（固态硬盘）编程（1）：简介和目录 #

本文由  [伯乐在线][Link 1]  -  [熊铎][Link 2]  翻译。未经许可，禁止转载！  
英文出处： [Emmanuel Goossaert (CodeCapsule.com)][Emmanuel Goossaert _CodeCapsule.com] 。欢迎加入 [翻译组][Link 3] 。

简介

我想为[我的键值对存储项目][Link 4]弄一个固态硬盘（SSD）最佳存储解决方案。为此，我必须确保我完全了解SSD是如何工作的，这样就可以优化我的hash表实例来适合SSD的内部特征。网上有很多不完全和相悖的的信息，找到关于SSD的可靠信息并不简单。为了找到适当的文献和基准以说服自己，我必须要进行大量的阅读。如果我要为SSD编程，我需要知道我在做什么。

研究完之后我搞明白了，相信将我所得到的结论向大家分享会有用的。我的意图是将所有的可用信息转化为实用知识。最后我写了一篇30页的文章，但它不太适合发布在博客上。因此我决定将这篇文章分为数个可被独立消化的数个逻辑部分。而目录在本文的下方。

[第六部分][Link 5]有最为显著的贡献，这一部分是整个“为SSD编程”文章系列的总结，我相信那些心急的程序员最为喜欢。这个总结涵盖了SSD的基本知识以及所有推荐的实现固态硬盘的最佳读写性能的访问模式。

另外一个重要的细节是，“为SSD编程”与我的键值对存储项目（[IKVS series][Link 4]）之间是相互独立的，因此并不需要IKVS文章中的知识。我正打算写一篇关于IKVS series的文章，内容是关于 如何用hash表来实现利用SSD的内部特征，不过我还没有具体的发布时间。

我唯一的遗憾就是，我还没有写任何代码，以证明我建议的访问模式确实是最好的。但是即使有这些代码，我也需要在大量不同的固态硬盘上测试性能基准，这将消耗我所不能承受的大量的时间和金钱。我仔细列举了我引用的文章，如果你认为我的建议不对，请留下评论指明。当然，如果你有什么疑问或想在任何方面做出贡献，请随意留下评论。

最后，不要忘了订阅电子报，以便在每当有新文章发表在Code Capsule上时能够收到通知。订阅面板在博客的右上角。

[第一部分：简介和目录][Link 6]

[第二部分：SSD的架构和基准][SSD]

1. SSD的结构  
1.1 NAND闪存单元  
1.2 SSD的组织  
1.3 制造过程

2. 基准和性能指标  
2.1 基本基准  
2.2 预处理  
2.3 任务负载和指标

[第三部分：页、块、和闪存转换层][Link 7]

3. 基本操作  
3.1 读、写、擦除  
3.2 写入的例子  
3.3 写入放大  
3.4 耗损均衡

4. 闪存转换层（FTL）  
4.1 FTL的必要性  
4.2 逻辑块映射  
4.3 产业状态的备注  
4.4 垃圾回收

[第四部分：高级功能和内部并行][Link 8]

5. 高级功能  
5.1 TRIM  
5.2 预留空间  
5.3 完全抹除  
5.4 本地命令队列(NCQ)  
5.5 掉电保护

6. SSD的内部并行  
6.1 被限制的I/O总线带宽  
6.2 多层并行  
6.3 块的集群

[第五部分：访问模式和系统优化][Link 9]

7. 访问模式  
7.1 定义顺序和随机I/O操作  
7.2 写入  
7.3 读出  
7.4 合并读写

8.系统操作  
8.1 分区对齐  
8.2 文件系统参数  
8.3 操作系统I/O调度  
8.4 交换空间  
8.5 临时文件

[第六部分：总结——每个程序员都应该了解的固态硬盘知识][Link 10]

下一部分

[第二部分][Link 11]在这。如果你比较忙，你可以直接去总结了所有其他部分内容的[第六部分][Link 10]

# 为SSD编程（2）：SSD的架构和基准 #

本第二部分包含了“为SSD编程”的6个内容，包括1、2两节，你可以参考[目录][Link 6]。这是我在阅读了各种关于SSD的文档之后，为了分享我所学到的东西写的一系列文章。如果你没有时间慢慢看，你可以直接跳转到[第六部分][Link 5]，这部分总结了所有其他部分的内容。

在本部分，我将解释NAND闪存的基本知识、闪存单元类型、和基本SSD内部架构。同样包括了SSD基准和如何解释这些基准。

![7cc829d3gw1ef85q6kljgj20k00botan.jpg][]

1. SSD的架构

1.1 NAND闪存单元

固态硬盘(SSD)是基于闪存的数据存储设备。每个数据位保存在由浮栅晶体管制成的闪存单元里。SSD整个都是由电子组件制成的，没有像硬盘那样的移动或者机械的部分。

在浮栅晶体管中，使用电压来实现每个位的读写和擦除。写晶体管有两个方法：NOR闪存和NAND闪存。我不会更加深入的讨论NOR和NAND闪存的不同。本文将只包含被大多数制造商采用的NAND闪存。更多关于NOR和 NAND的不同点的信息，你可以参考Lee Hutchinson写的这篇文章[\[31\]][31]

NAND闪存模块的一个重要特征是，他们的闪存单元是损耗性的，因此它们有一个寿命。实际上，晶体管是通过保存电子来实现保存比特信息的。在每个P/E循环（Program/Erase，“Program”在这表示写）中电子可能被晶体管误捕，一段是时间以后，大量电子被捕获会使得闪存单元不可用。

有限的寿命

每个单元有一个最大的P/E 循环数量，当闪存单元被认为有缺陷后，NAND闪存被损耗而拥有一个有限的寿命。不同类型的NAND闪存有不同的寿命[\[31\]][31]。

最近的研究表示，通过给NAND一个相当高的温度，被捕获的电子可以被清除[\[14, 51\]][31]。尽管这仍然还只是研究，并且还没有确定到底哪一天能够将这个研究应用的消费市场，但这确实可以极大地增加SSD的寿命。

目前业界中的闪存单元类型有：

*  单层单元（SLC），这种的晶体管只能存储一个比特但寿命很长。
 *  多层单元（MLC），这种的晶体管可以存储2个比特，但是会导致增加延迟时间和相对于SLC减少寿命。
 *  三层单元（TLC），这种的晶体管可以保存3个比特，但是会有更高的延迟时间和更短的寿命。

闪存单元类型

固态硬盘（SSD）是基于闪存的数据存储设备。比特存储在闪存单元中，有三种闪存单元类型：每个单元1比特（单层单元，SLC），每个单元2比特（多层单元，MLC），和每单元3比特（三层单元，TLC）。

下方的表1中是每种NAND类型的详细信息。为了比较，我添加了硬盘、内存、和L1/L2缓存的平均延迟。

表1：NAND闪存不同类型的特征和用时与其他记忆组件比较

在相同数量的晶体管中的比特数更多可以降低生产成本。与基于MLC的SSD相比，基于SLC的SSD更可靠，并具有更长的寿命，但是有更高的生产成本。因此一般的大众SSD是基于MLC或者TLC的，只有专业的SSD是基于SLC的。因此往往会基于硬盘的目标工作负载和可能的数据更新频率，选择正确的存储类型。对于较高的更新工作负载，SLC是最后的选择，而高读取低写入的工作负载（例如视频存储和直播），TLC将极其适合。另外，TLC硬盘基于实际工作负载的基准检测显示出在实际中不必考虑基于TLC的SSD寿命。

NAND闪存的页和块

闪存的模块组织在被称为块的格子中，而块则组织成平面。块中可以读写的最小单元称为页。页不能独立擦除，只能整块擦除。NAND闪存的页大小可能是不一样的，大多数硬盘的页大小是2 KB, 4 KB, 8 KB 或 16 KB。大多数SSD的块有128或256页，这即表示块的大小也可能是256KB和4MB之间不同的值。例如Samsung SSD 840 EVO的块大小是2048KB，而每个块有256个8KB的页。页和块访问的细节在3.1节中

1.2 SSD的组织

下方的图1是SSD硬盘及其组件的示例。我只是重复了数篇论文[\[2, 3, 6\]][31]中已有的基本示意图。

![7cc829d3gw1ef85q7sue8j20k00bimyd.jpg][]

图1：固态硬盘的架构

来自用户的命令是通过主机接口交换的。在我写这篇文章的时候，最新发布的SSD有两种最普遍的接口：SATA和PCIe。SSD控制器中的处理器接收这些命令并将它们传递给闪存控制器。SSD同样内嵌有RAM存储器，通常是作为缓存和存储映射信息使用。章节4包含了关于映射策略的细节信息。NAND闪存芯片通过多个通道组织在一起，和这些通道有关的信息在章节6中。

下方的图2和图3是从StorageReview.com [\[26, 27\]][31] 复制过来的，展示出真的SSD是长的什么样子的。

*  1个SATA3.0接口
 *  1个SSD控制器（Samsung MDX S4LN021X01-8030）
 *  1个RAM模块（256 MB DDR2 Samsung K4P4G324EB-FGC2）
 *  8个MLC NAND闪存模块，每个模块有64G的存储空间（Samsung K9PHGY8U7A-CCK0）

![7cc829d3gw1ef85q8qf2bj20k00a63zm.jpg][]

图2：三星固态硬盘840 Pro（512 GB）— 感谢StorageReview.com[\[26\]][31] 的图片

![7cc829d3gw1ef85q9dhluj20k00detbp.jpg][]

图3是一个美光P420m 企业级PCIe固态硬盘，2013年末发布。主要组件有：

*  PCIe 2.0接口 x8
 *  1个SSD控制器
 *  1个RAM模块（DRAM DDR3）
 *  32通道上的64个MLC NAND闪存模块，每个模块有32GB的存储空间（Micron 31C12NQ314?25nm）

总存储空间为2048GB，但在应用over-provisioning技术后只有1.4TB可用。

![7cc829d3gw1ef85qaoqocj20k005s750.jpg][]

![7cc829d3gw1ef85qb8fwhj20k00cggn8.jpg][]

图3：美光P420m企业级PCIe固态硬盘（1.4TB）— 感谢StorageReview.com[\[27\]][31] 的图片

1.3生产过程

很多SSD的生产商使用表面贴装技术（SMT，电子组件直接放置在PCB板上的一种生产方法）来生产SSD。SMT生产线由一系列机器组成，每个机器上下衔接，并有各自生产过程中的任务，例如安放组件或者融化焊锡。整个生产过程中同样贯穿了多重质量检测。Steve Burke的两篇参观金士顿在加利福利亚芳泉谷市的生产工厂的文章[\[67, 68\]][31]和Cameron Wilmot的一篇关于台湾金士顿组装工厂的文章[\[69\]][31]中，有SMT生产线的照片和视频。

另外还有两个有趣的视频，一个是关于美光Crucial SSD[\[70\]][31]的，而另一个是关于金士顿[\[71\]][31]。后边一个视频是Steve Burke文章的一部分，我同样在下方引用了。金士顿的Mark Tekunoff领读者参观了他们SMT生产线。有意思的是，视频中的每个人都穿着一套萌萌的抗静电服，看起来很有意思。

2.基准和性能度量

2.1基本基准

下边的表2展示的是不同的固态硬盘在顺序和随机工作负载下的读写速度。为了便于比较，这里包含了2008年到2013年发布的SSD、一个硬盘盒、和一个内存芯片

<table style="border: 1px solid rgb(232, 232, 232); margin: 0px 0px 20px; padding: 0px 5px; font-size: 15px; border-collapse: collapse; border-spacing: 0px; width: 599px;"> 
 <tbody style="border: 0px; margin: 0px; padding: 0px;"> 
 <tr style="border-width: 0px 0px 1px; border-bottom-style: solid; border-bottom-color: rgb(232, 232, 232); margin: 0px; padding: 0px;"> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">&nbsp;</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">Samsung 64 GB</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">Intel X25-M</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">Samsung 840 EVO</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">Micron P420m</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">HDD</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">RAM</td> 
 </tr> 
 <tr style="border-width: 0px 0px 1px; border-bottom-style: solid; border-bottom-color: rgb(232, 232, 232); margin: 0px; padding: 0px;"> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">品牌 / 型号</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">Samsung(MCCDE64G5MPP-OVA)</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">Intel X25-M(SSDSA2MH080G1GC)</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">Samsung(SSD 840 EVO mSATA)</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">Micron P420m</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">Western Digital Black 7200 rpm</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">Corsair Vengeance DDR3</td> 
 </tr> 
 <tr style="border-width: 0px 0px 1px; border-bottom-style: solid; border-bottom-color: rgb(232, 232, 232); margin: 0px; padding: 0px;"> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">存储单元类型</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">MLC</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">MLC</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">TLC</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">MLC</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">*</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">*</td> 
 </tr> 
 <tr style="border-width: 0px 0px 1px; border-bottom-style: solid; border-bottom-color: rgb(232, 232, 232); margin: 0px; padding: 0px;"> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">上市年份</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">2008</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">2008</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">2013</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">2013</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">2013</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">2012</td> 
 </tr> 
 <tr style="border-width: 0px 0px 1px; border-bottom-style: solid; border-bottom-color: rgb(232, 232, 232); margin: 0px; padding: 0px;"> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">接口</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">SATA 2.0</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">SATA 2.0</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">SATA 3.0</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">PCIe 2.0</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">SATA 3.0</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">*</td> 
 </tr> 
 <tr style="border-width: 0px 0px 1px; border-bottom-style: solid; border-bottom-color: rgb(232, 232, 232); margin: 0px; padding: 0px;"> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">总容量</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">64 GB</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">80 GB</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">1 TB</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">1.4 TB</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">4 TB</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">4 x 4 GB</td> 
 </tr> 
 <tr style="border-width: 0px 0px 1px; border-bottom-style: solid; border-bottom-color: rgb(232, 232, 232); margin: 0px; padding: 0px;"> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">每块的页数</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">128</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">128</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">256</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">512</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">*</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">*</td> 
 </tr> 
 <tr style="border-width: 0px 0px 1px; border-bottom-style: solid; border-bottom-color: rgb(232, 232, 232); margin: 0px; padding: 0px;"> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">页大小</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">4 KB</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">4 KB</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">8 KB</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">16 KB</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">*</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">*</td> 
 </tr> 
 <tr style="border-width: 0px 0px 1px; border-bottom-style: solid; border-bottom-color: rgb(232, 232, 232); margin: 0px; padding: 0px;"> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">块大小</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">512 KB</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">512 KB</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">2048 KB</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">8196 KB</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">*</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">*</td> 
 </tr> 
 <tr style="border-width: 0px 0px 1px; border-bottom-style: solid; border-bottom-color: rgb(232, 232, 232); margin: 0px; padding: 0px;"> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">顺序读取 (MB/s)</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">100</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">254</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">540</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">3300</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">185</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">7233</td> 
 </tr> 
 <tr style="border-width: 0px 0px 1px; border-bottom-style: solid; border-bottom-color: rgb(232, 232, 232); margin: 0px; padding: 0px;"> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">顺序写入 (MB/s)</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">92</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">78</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">520</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">630</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">185</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">5872</td> 
 </tr> 
 <tr style="border-width: 0px 0px 1px; border-bottom-style: solid; border-bottom-color: rgb(232, 232, 232); margin: 0px; padding: 0px;"> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">4KB 随机读取(MB/s)</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">17</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">23.6</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">383</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">2292</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">0.54</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">5319 **</td> 
 </tr> 
 <tr style="border-width: 0px 0px 1px; border-bottom-style: solid; border-bottom-color: rgb(232, 232, 232); margin: 0px; padding: 0px;"> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">4KB 随机写入 (MB/s)</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">5.5</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">11.2</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">352</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">390</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">0.85</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">5729 **</td> 
 </tr> 
 <tr style="border-width: 0px 0px 1px; border-bottom-style: solid; border-bottom-color: rgb(232, 232, 232); margin: 0px; padding: 0px;"> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">4KB 随机读取(KIOPS)</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">4</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">6</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">98</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">587</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">0.14</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">105</td> 
 </tr> 
 <tr style="border-width: 0px 0px 1px; border-bottom-style: solid; border-bottom-color: rgb(232, 232, 232); margin: 0px; padding: 0px;"> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">4KB 随机写入 (KIOPS)</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">1.5</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">2.8</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">90</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">100</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">0.22</td> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">102</td> 
 </tr> 
 <tr style="border-width: 0px 0px 1px; border-bottom-style: solid; border-bottom-color: rgb(232, 232, 232); margin: 0px; padding: 0px;"> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">注意</td> 
 <td colspan="6" style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">* 存储设备不支持该指标 ** 以2MB的块测量,而非 4 KB</td> 
 </tr> 
 <tr style="border-width: 0px 0px 1px; border-bottom-style: solid; border-bottom-color: rgb(232, 232, 232); margin: 0px; padding: 0px;"> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">指标</td> 
 <td colspan="6" style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">MB/s: MB每秒 KIOPS:千操作每秒,每秒1000输入/输出操作</td> 
 </tr> 
 <tr style="border-width: 0px 0px 1px; border-bottom-style: solid; border-bottom-color: rgb(232, 232, 232); margin: 0px; padding: 0px;"> 
 <td style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">引用</td> 
 <td colspan="6" style="border-width: 0px 1px 0px 0px; border-right-style: solid; border-right-color: rgb(232, 232, 232); margin: 0px; padding: 5px; font-size: 15px; vertical-align: middle; text-align: center;">Samsung 64 GB<a href="http://blog.jobbole.com/63881/#ref" style="border: 0px; margin: 0px; padding: 0px; text-decoration: none; color: rgb(0, 153, 204);" rel="nofollow">[21]</a> Intel X25-M<a href="http://blog.jobbole.com/63881/#ref" style="border: 0px; margin: 0px; padding: 0px; text-decoration: none; color: rgb(0, 153, 204);" rel="nofollow">[2, 28]</a> Samsung SSD 840 EVO<a href="http://blog.jobbole.com/63881/#ref" style="border: 0px; margin: 0px; padding: 0px; text-decoration: none; color: rgb(0, 153, 204);" rel="nofollow">[22]</a> Micron P420M<a href="http://blog.jobbole.com/63881/#ref" style="border: 0px; margin: 0px; padding: 0px; text-decoration: none; color: rgb(0, 153, 204);" rel="nofollow">[27]</a> Western Digital Black 4 TB<a href="http://blog.jobbole.com/63881/#ref" style="border: 0px; margin: 0px; padding: 0px; text-decoration: none; color: rgb(0, 153, 204);" rel="nofollow">[25]</a> Corsair Vengeance DDR3 RAM<a href="http://blog.jobbole.com/63881/#ref" style="border: 0px; margin: 0px; padding: 0px; text-decoration: none; color: rgb(0, 153, 204);" rel="nofollow">[30]</a></td> 
 </tr> 
 </tbody> 
</table>

表2: 固态硬盘与其他存储设备比较，特征和读写速度

影响性能的一个重要因素是接口。最新发布的SSD最常使用的接口是SATA3.0和PCI Express 3.0。使用SATA3.0接口时，数据传输速度可以达到6 Gbit/s，而在实际上大概能够达到550MB/s。而使用PCIe 3.0可以达到每条8 GT/s，而实际上能达到大概1 GB/s（GT/s是指G次传输（Gigatransfers）每秒）。使用PCIe 3.0接口的SSD都会使用不止一条通道。使用4条通道的话（译注：PCIe 3.0 x4），PCIe 3.0可以提供最大4 GB/s,的带宽，相当于SATA3.0的四倍一些企业级的SSD同样提供串行SCSI接口（SAS），最新版本的SAS可以提供最高12 GBit/s的速度，但是现在SAS的市场占有量很小。

大部分近期的的SSD的内部速度可以满足550 MB/s的SATA3.0限制，因此接口是其速度瓶颈。使用PCI Express 3.0或者SAS的SSD可以提供巨大的性能提升。

PCI Express 和SAS 比 SATA要快

生产商提供的两个主要接口是SATA3.0(550MB/s)和PCI Express 3.0 (每通道1 GB/s, 使用多个通道)。串行SCSI（SAS）同样应用在企业级SSD上。最新版本的接口定义中PCI Express 和SAS 比 SATA要快，但是同样要更贵。

2.2 预处理

如果你折磨数据足够久，它会招的 —— Ronald Coase

SSD生产商提供的数据资料充斥着令人惊讶的性能值。确实，通过各种乱七八糟的方法对数据处理足够长的时间，生产商似乎总能找到方法在商业传单上显摆那些闪亮的数字。这些数字是否真的有意义，或者能否真的反映产品系统的性能则是另外的问题。Marc Bevand在他关于常见SSD性能基准缺陷的文章中[\[66\]][31]，提到了一些例子。例如常见的报道随机写负载的IOPS（每秒读写操作次数）而不提所跨的LBA（逻辑区块地址）的范围，很多IOPS的数据只是基于队列深度为1，而非整个硬盘最大值而测试的。同样也有很多基准性能测试工具误用的例子。

正确评估SSD的性能并非易事。硬件评测博客上的很多文章都是在硬盘上随机写十分钟，便声称硬盘可以进行测试，并且测试结果是可信的。然而SSD性能只会在足够长时间的随机写工作负载下才会有性能降低，而所需的时间基于SSD的总大小会花费30分钟到3小时不等。这即是更多认真的基准性能测试开始于相当长时间的随机写负载（称为“预处理”）的原因[\[50\]][31]。下方的图7来自StorageReview.com上的一篇文章[\[26\]][31]，显示出在多个SSD上预处理的效果。可以看见在30分钟左右出现了明显的性能下降，所有硬盘都出现读写速度下降和延迟上升。之后的四个小时中，硬盘性能缓慢降低到一个最小的常量值。

![7cc829d3gw1ef85qcnrakj20k00n1jvm.jpg][]

图7：多个SSD上预处理的效果 — 感谢来自StorageReview.com[\[26\]][31]的图片

5.2节解释了图7中实际上发生的事情，随机写入的量太大并以这种持续的方式进行使得垃圾回收进程不能维持在后台。因为必须在写命令到达时擦除块，因此垃圾回收进程必须和来自主机的工作在前台的操作竞争。使用预处理的人声称基准测试可以代表硬盘在最坏的情况下的表现。这种方法在所有工作负载下是否都是好模型还是值得商榷。

为了比较不同制造商的各种产品，找到可以比较的共同点是必要的，而最坏的情况是一个有效的共同点。然而选择在最糟糕的工作负载下表现最好的硬盘并不能保证其在生产环境下所有的工作负载下都表现的最好。实际上大部分的生产环境下，SSD硬盘只会在唯一的一个系统下工作。因其内部特征，这个系统有一个特定的工作负载。因此比较不同硬盘的更好更精确的方法是在这些硬盘上运行完全相同的工作负载，然后比较他们表现的性能。 这就是为何，即使使用持续的随机写工作负载的预处理可以公平的比较不同SSD，但还是有一点需要注意，如果可以的话，运行一个内部的基于目标工作负载的基准测试。

内部基准测试同样可以通过避免使用“最好的”SSD来避免过度调配资源，譬如当一个比较便宜的SSD型号已经足够并且能够省下一大笔钱的时候。

基准测试很难

测试者是人，因此并不是所有的基准测试都是没有错的。在使用生产商或者第三方的基准测试的时候请小心，并且在相信这些数据之前参考多个消息源，孤证不立。如果可以的话，使用你系统的特定工作负载来进行你自己的内部基准测试。

2.3工作负载和指标

性能基准都有相同的指标，并使用相同的度量。在本节中，对于如何解释这些指标，我希望能够给出一些见解。

通常使用的参数如下：

*  工作负载类型：可以是基于用户控制数据的指定性能基准，或者只是顺序或者随机访问的性能基准（例：仅随机写）
 *  读写百分比（例：30%读70%写）
 *  队列长度：在硬盘上运行命令的并发执行线程的数量
 *  访问的数据块大小（4 KB 8 KB等）

:基准测试的结果可能使用不同的度量指标。常用的如下：

*  吞吐量：数据传输的速度，通常单位是KB/s或MB/s，表示千字节每秒和百万字节每秒。这个指标常用在顺序读写基准测试中。
 *  IOPS:每秒读写操作的数量，每个操作都是相同大小的数据块（通常是4KB/S）。这个指标通常用在随机读写基准测试中。[\[17\]][31]
 *  延迟：在发送完命令后设备的反应时间，通常是μs或ms，表示微秒或者毫秒。

虽然吞吐量这个指标很容易理解和接受，但IOPS却比较难以领会。例如，如果一个硬盘在随机写上的表现是在4KB的数据块上是1000 IOPS，这即表示吞吐量是1000 x 4096 = 4 MB/s.。因此，IOPS高只有在数据块足够大的时候才可以被解释成吞吐量高，而IOPS高但平均数据块小的话只能代表一个低吞吐量。

为了阐明这个观点，不妨想象我们有一个登陆服务器，每分钟要对数千个不同的文件执行微量的更新，表现出10k IOPS的性能。因为这些更新分布在如此多的文件里，吞吐量能够接近20 MB/s，然而在同一个服务器中仅对同一个文件进行顺序写入能够将吞吐量提高到200 MB/s，这可是10倍的提升。例子中的数字是我编的，不过这些数据很接近我接触到的生产环境。

另一个需要掌握的概念是，高吞吐量并不足以表示这是一个快的系统。实际上，如果延迟很高，不管吞吐量有多么好，整个系统还是会慢。让我们拿一个假象的单线程进程为例，这个进程需要连接25个数据库，每个数据库都有20ms的延迟。因为连接的延迟是累积的，获取25个连接需要5 x 20 ms = 500 ms。因此，即便运行数据库查询的机器有很快的网卡，就当5 GBits/s的带宽吧，但这个脚本仍然因为延迟而会很慢。

本节的重点在于，着眼于全部的指标是很重要的，这些指标会显示出系统的不同特征，并且可以在瓶颈出现时识别出来。当在看SSD的基准测试并确定所选择的型号时，通常有一个很好的经验就是，别忘了这些待选的SSD中，哪个指标对于系统是最关键的。

对于这个主题有一个很有意思的扩展阅读：Jeremiah Peschka 写的一篇文章“IOPS是骗局”[\[46\]][31]。

下一部分

第三部分在这。你同样可以去内容目录来看看这一系列的文章。如果你时间很紧，你同样可以直接去总结了所有其他部分的内容的第六部分。

引用

\[1\][Understanding Intrinsic Characteristics and System Implications of Flash Memory based Solid State Drives, Chen et al., 2009][Understanding Intrinsic Characteristics and System Implications of Flash Memory based Solid State Drives_ Chen et al._ 2009]  
\[2\][Parameter-Aware I/O Management for Solid State Disks (SSDs), Kim et al., 2012][Parameter-Aware I_O Management for Solid State Disks _SSDs_ Kim et al._ 2012]  
\[3\][Essential roles of exploiting internal parallelism of flash memory based solid state drives in high-speed data processing, Chen et al, 2011][Essential roles of exploiting internal parallelism of flash memory based solid state drives in high-speed data processing_ Chen et al_ 2011]  
\[4\][Exploring and Exploiting the Multilevel Parallelism Inside SSDs for Improved Performance and Endurance, Hu et al., 2013][Exploring and Exploiting the Multilevel Parallelism Inside SSDs for Improved Performance and Endurance_ Hu et al._ 2013]  
\[5\][Design Tradeoffs for SSD Performance, Agrawal et al., 2008][Design Tradeoffs for SSD Performance_ Agrawal et al._ 2008]  
\[6\][Design Patterns for Tunable and Efficient SSD-based Indexes, Anand et al., 2012][Design Patterns for Tunable and Efficient SSD-based Indexes_ Anand et al._ 2012]  
\[7\][BPLRU: A Buffer Management Scheme for Improving Random Writes in Flash Storage, Kim et al., 2008][BPLRU_ A Buffer Management Scheme for Improving Random Writes in Flash Storage_ Kim et al._ 2008]  
\[8\][SFS: Random Write Considered Harmful in Solid State Drives, Min et al., 2012][SFS_ Random Write Considered Harmful in Solid State Drives_ Min et al._ 2012]  
\[9\][A Survey of Flash Translation Layer, Chung et al., 2009][A Survey of Flash Translation Layer_ Chung et al._ 2009]  
\[10\][A Reconfigurable FTL (Flash Translation Layer) Architecture for NAND Flash-Based Applications, Park et al., 2008][A Reconfigurable FTL _Flash Translation Layer_ Architecture for NAND Flash-Based Applications_ Park et al._ 2008]  
\[11\][Reliably Erasing Data From Flash-Based Solid State Drives, Wei et al., 2011][Reliably Erasing Data From Flash-Based Solid State Drives_ Wei et al._ 2011]  
\[12\][http://en.wikipedia.org/wiki/Solid-state\_drive][http_en.wikipedia.org_wiki_Solid-state_drive]  
\[13\][http://en.wikipedia.org/wiki/Write\_amplification][http_en.wikipedia.org_wiki_Write_amplification]  
\[14\][http://en.wikipedia.org/wiki/Flash\_memory][http_en.wikipedia.org_wiki_Flash_memory]  
\[15\][http://en.wikipedia.org/wiki/Serial\_ATA][http_en.wikipedia.org_wiki_Serial_ATA]  
\[16\][http://en.wikipedia.org/wiki/Trim\_(computing)][http_en.wikipedia.org_wiki_Trim_computing]  
\[17\][http://en.wikipedia.org/wiki/IOPS][http_en.wikipedia.org_wiki_IOPS]  
\[18\][http://en.wikipedia.org/wiki/Hard\_disk\_drive][http_en.wikipedia.org_wiki_Hard_disk_drive]  
\[19\][http://en.wikipedia.org/wiki/Hard\_disk\_drive\_performance\_characteristics][http_en.wikipedia.org_wiki_Hard_disk_drive_performance_characteristics]  
\[20\][http://centon.com/flash-products/chiptype][http_centon.com_flash-products_chiptype]  
\[21\][http://www.thessdreview.com/our-reviews/samsung-64gb-mlc-ssd/][http_www.thessdreview.com_our-reviews_samsung-64gb-mlc-ssd]  
\[22\][http://www.anandtech.com/show/7594/samsung-ssd-840-evo-msata-120gb-250gb-500gb-1tb-review][http_www.anandtech.com_show_7594_samsung-ssd-840-evo-msata-120gb-250gb-500gb-1tb-review]  
\[23\][http://www.anandtech.com/show/6337/samsung-ssd-840-250gb-review/2][http_www.anandtech.com_show_6337_samsung-ssd-840-250gb-review_2]  
\[24\][http://www.storagereview.com/ssd\_vs\_hdd][http_www.storagereview.com_ssd_vs_hdd]  
\[25\][http://www.storagereview.com/wd\_black\_4tb\_desktop\_hard\_drive\_review\_wd4003fzex][http_www.storagereview.com_wd_black_4tb_desktop_hard_drive_review_wd4003fzex]  
\[26\][http://www.storagereview.com/samsung\_ssd\_840\_pro\_review][http_www.storagereview.com_samsung_ssd_840_pro_review]  
\[27\][http://www.storagereview.com/micron\_p420m\_enterprise\_pcie\_ssd\_review][http_www.storagereview.com_micron_p420m_enterprise_pcie_ssd_review]  
\[28\][http://www.storagereview.com/intel\_x25-m\_ssd\_review][http_www.storagereview.com_intel_x25-m_ssd_review]  
\[29\][http://www.storagereview.com/seagate\_momentus\_xt\_750gb\_review][http_www.storagereview.com_seagate_momentus_xt_750gb_review]  
\[30\][http://www.storagereview.com/corsair\_vengeance\_ddr3\_ram\_disk\_review][http_www.storagereview.com_corsair_vengeance_ddr3_ram_disk_review]  
\[31\][http://arstechnica.com/information-technology/2012/06/inside-the-ssd-revolution-how-solid-state-disks-really-work/][http_arstechnica.com_information-technology_2012_06_inside-the-ssd-revolution-how-solid-state-disks-really-work]  
\[32\][http://www.anandtech.com/show/2738][http_www.anandtech.com_show_2738]  
\[33\][http://www.anandtech.com/show/2829][http_www.anandtech.com_show_2829]  
\[34\][http://www.anandtech.com/show/6489][http_www.anandtech.com_show_6489]  
\[35\][http://lwn.net/Articles/353411/][http_lwn.net_Articles_353411]  
\[36\][http://us.hardware.info/reviews/4178/10/hardwareinfo-tests-lifespan-of-samsung-ssd-840-250gb-tlc-ssd-updated-with-final-conclusion-final-update-20-6-2013][http_us.hardware.info_reviews_4178_10_hardwareinfo-tests-lifespan-of-samsung-ssd-840-250gb-tlc-ssd-updated-with-final-conclusion-final-update-20-6-2013]  
\[37\][http://www.anandtech.com/show/6489/playing-with-op][http_www.anandtech.com_show_6489_playing-with-op]  
\[38\][http://www.ssdperformanceblog.com/2011/06/intel-320-ssd-random-write-performance/][http_www.ssdperformanceblog.com_2011_06_intel-320-ssd-random-write-performance]  
\[39\][http://en.wikipedia.org/wiki/Native\_Command\_Queuing][http_en.wikipedia.org_wiki_Native_Command_Queuing]  
\[40\][http://superuser.com/questions/228657/which-linux-filesystem-works-best-with-ssd/][http_superuser.com_questions_228657_which-linux-filesystem-works-best-with-ssd]  
\[41\][http://blog.superuser.com/2011/05/10/maximizing-the-lifetime-of-your-ssd/][http_blog.superuser.com_2011_05_10_maximizing-the-lifetime-of-your-ssd]  
\[42\][http://serverfault.com/questions/356534/ssd-erase-block-size-lvm-pv-on-raw-device-alignment][http_serverfault.com_questions_356534_ssd-erase-block-size-lvm-pv-on-raw-device-alignment]  
\[43\][http://rethinkdb.com/blog/page-alignment-on-ssds/][http_rethinkdb.com_blog_page-alignment-on-ssds]  
\[44\][http://rethinkdb.com/blog/more-on-alignment-ext2-and-partitioning-on-ssds/][http_rethinkdb.com_blog_more-on-alignment-ext2-and-partitioning-on-ssds]  
\[45\][http://rickardnobel.se/storage-performance-iops-latency-throughput/][http_rickardnobel.se_storage-performance-iops-latency-throughput]  
\[46\][http://www.brentozar.com/archive/2013/09/iops-are-a-scam/][http_www.brentozar.com_archive_2013_09_iops-are-a-scam]  
\[47\][http://www.acunu.com/2/post/2011/08/why-theory-fails-for-ssds.html][http_www.acunu.com_2_post_2011_08_why-theory-fails-for-ssds.html]  
\[48\][http://security.stackexchange.com/questions/12503/can-wiped-ssd-data-be-recovered][http_security.stackexchange.com_questions_12503_can-wiped-ssd-data-be-recovered]  
\[49\][http://security.stackexchange.com/questions/5662/is-it-enough-to-only-wipe-a-flash-drive-once][http_security.stackexchange.com_questions_5662_is-it-enough-to-only-wipe-a-flash-drive-once]  
\[50\][http://searchsolidstatestorage.techtarget.com/feature/The-truth-about-SSD-performance-benchmarks][http_searchsolidstatestorage.techtarget.com_feature_The-truth-about-SSD-performance-benchmarks]  
\[51\][http://www.theregister.co.uk/2012/12/03/macronix\_thermal\_annealing\_extends\_life\_of\_flash\_memory/][http_www.theregister.co.uk_2012_12_03_macronix_thermal_annealing_extends_life_of_flash_memory]  
\[52\][http://www.eecs.berkeley.edu/~rcs/research/interactive\_latency.html][http_www.eecs.berkeley.edu_rcs_research_interactive_latency.html]  
\[53\][http://blog.nuclex-games.com/2009/12/aligning-an-ssd-on-linux/][http_blog.nuclex-games.com_2009_12_aligning-an-ssd-on-linux]  
\[54\][http://www.linux-mag.com/id/8397/][http_www.linux-mag.com_id_8397]  
\[55\][http://tytso.livejournal.com/2009/02/20/][http_tytso.livejournal.com_2009_02_20]  
\[56\][https://wiki.debian.org/SSDOptimization][https_wiki.debian.org_SSDOptimization]  
\[57\][http://wiki.gentoo.org/wiki/SSD][http_wiki.gentoo.org_wiki_SSD]  
\[58\][https://wiki.archlinux.org/index.php/Solid\_State\_Drives][https_wiki.archlinux.org_index.php_Solid_State_Drives]  
\[59\][https://www.kernel.org/doc/Documentation/block/cfq-iosched.txt][https_www.kernel.org_doc_Documentation_block_cfq-iosched.txt]  
\[60\][http://www.danielscottlawrence.com/blog/should\_i\_change\_my\_disk\_scheduler\_to\_use\_NOOP.html][http_www.danielscottlawrence.com_blog_should_i_change_my_disk_scheduler_to_use_NOOP.html]  
\[61\][http://www.phoronix.com/scan.php?page=article&item=linux\_iosched\_2012][http_www.phoronix.com_scan.php_page_article_item_linux_iosched_2012]  
\[62\][http://www.velobit.com/storage-performance-blog/bid/126135/Effects-Of-Linux-IO-Scheduler-On-SSD-Performance][http_www.velobit.com_storage-performance-blog_bid_126135_Effects-Of-Linux-IO-Scheduler-On-SSD-Performance]  
\[63\][http://www.axpad.com/blog/301][http_www.axpad.com_blog_301]  
\[64\][http://en.wikipedia.org/wiki/List\_of\_solid-state\_drive\_manufacturers][http_en.wikipedia.org_wiki_List_of_solid-state_drive_manufacturers]  
\[65\][http://en.wikipedia.org/wiki/List\_of\_flash\_memory\_controller\_manufacturers][http_en.wikipedia.org_wiki_List_of_flash_memory_controller_manufacturers]  
\[66\][http://blog.zorinaq.com/?e=29][http_blog.zorinaq.com_e_29]  
\[67\][http://www.gamersnexus.net/guides/956-how-ssds-are-made][http_www.gamersnexus.net_guides_956-how-ssds-are-made]  
\[68\][http://www.gamersnexus.net/guides/1148-how-ram-and-ssds-are-made-smt-lines][http_www.gamersnexus.net_guides_1148-how-ram-and-ssds-are-made-smt-lines]  
\[69\][http://www.tweaktown.com/articles/4655/kingston\_factory\_tour\_making\_of\_an\_ssd\_from\_start\_to\_finish/index.html][http_www.tweaktown.com_articles_4655_kingston_factory_tour_making_of_an_ssd_from_start_to_finish_index.html]  
\[70\][http://www.youtube.com/watch?v=DvA9koAMXR8][http_www.youtube.com_watch_v_DvA9koAMXR8]  
\[71\][http://www.youtube.com/watch?v=3s7KG6QwUeQ][http_www.youtube.com_watch_v_3s7KG6QwUeQ]  
\[72\][Understanding the Robustness of SSDs under Power Fault, Zheng et al., 2013][Understanding the Robustness of SSDs under Power Fault_ Zheng et al._ 2013]—[\[discussion on HN\]][discussion on HN]  
\[73\][http://lkcl.net/reports/ssd\_analysis.html][http_lkcl.net_reports_ssd_analysis.html]—[\[discussion on HN\]][discussion on HN 1]

# 为SSD编程（3）：页、块和闪存转换层 #

在这个部分，我会解释写操作在页和块级是如何处理的，以及写入放大和损耗均衡计算的基本概念。此外，我描述了闪存转换层（FTL）的概念，以及应用了闪存转换层的两个技术：逻辑块地址映射和垃圾回收。更详细的说，我解释了在混合逻辑块映射背景下的写操作是怎么实现的。

![7cc829d3gw1efqfq6pr4bj20k00e1myw.jpg][]

3. 基本操作

3.1 读出、写入、擦除

因为NAND闪存单元的组织结构限制，单独读写一个闪存单元是不可能的。存储单元被组织起来并有着十分特别的属性。要知道这些属性对于为固态硬盘优化数据结构的过程和理解其行为来说是很重要的。我 在下方描述了关于读写擦除操作的SSD的基本属性

读是以页大小对齐的

一次读取少于一页的内容是不可能的。操作系统当然可以只请求一字节，但是SSD会访问整个页，强制读取远超所需的数据。

写是以页大小对齐的

将数据写入SSD的时候，写入的增量也是页大小。因此即使一个写入操作只影响到一个字节，无论如何整个页都会写入。写入比所需更多的数据的行为被称为写入放大，其概念在3.3节。另外，向某页写入的行为有时候被称为“编置（to program）”一页，因此在大多数关于SSD的出版物和文章中“write 写”和“program编置”是可以互相替换的

页不能被复写

NAND闪存页只有在其“空闲”着的时候才能写入。当数据改变后，这页的内容被拷贝到一个内部寄存器，此时数据更新而新版本的数据存储在一个“空闲”的页中，这被称为“读-改-写”操作。数据并非就地更新，因为“空闲”页与原来存储数据的页不是同一个页。一旦数据被硬盘保存，原先的页被标记为“stale（意为 腐败的 不新鲜的）”，直到其被擦除。

擦除以块对齐

页不能被复写，而一旦其成为stale，让其重新空闲下来的唯一方法是擦除他们。但是对单个页进行擦除是不可能的，只能一次擦除整个块。在用户看来，访问数据的时候只有读和写命令。擦除命令则是当SSD控制器需要回收stale页来获取空闲空间的时候，由其垃圾回收进程触发。

3.2 写入的例子

让我们用个例子来理清3.1节的这些概念。下边的图4是向SSD写入的一个例子。只显示了两个块，每个块有4个页。显然这是一个为了简化我在这使用的例子而精简的NAND闪存封装示意。图中的每一步里，图右侧的圆点解释了发生的事情

![7cc829d3gw1efqfq7ix13j20k00l5q5e.jpg][]

图4：向固态硬盘中写数据

3.3 写入放大

因为写入是按页大小对齐的，任何没有对齐一个或者多个页大小的写操作都会写入大于所需的数据，这是写入放大的概念[\[13\]][13]。写一个字节最终导致一整页都要写入，而一页的大小在某些型号的SSD中可能达到16KB，这是相当没有效率的。

而这不是唯一的问题。除了写入过多的数据外，这些额外的写入也会触发更多不必要的内部操作。实际上，用未对齐的方法写入数据会导致在更改和写回硬盘之前需要页读到缓存，这比直接写入硬盘要慢。这个操作被称为读-改-写，且应该尽可能的避免[\[2, 5\]][13]。

绝不进行少于一页的写入

避免写入小于NAND闪存页大小的数据块来最小化写入放大和读-改-写操作。现在一页的大小最大的是16KB，因此这个值应作为缺省值使用。闪存页大小的值基于SSD型号并且在未来SSD发展中可能会增加。

对齐写入

以页大小对齐写入，并写入大小为数个页大小的数据块。

缓存化小写入

为了最大化吞吐量，尽可能的将小数据写入RAM缓存中，当缓存满了之后执行一个大的写入来合并所有的小写入。

3.4 损耗均衡

如我们在1.1节讨论的那样，NAND闪存单元因其有P/E循环限制导致其有生命限制。想象一下我们有一个SSD，数据总是在同一个块上写入。这个块将很快达到其P/E循环限制、耗尽。而SSD控制器井标记其为不可用。这样硬盘的容量将减小。想象一下买了一个500GB的硬盘，过了几年还剩250G，这会非常恼火。

因此，SSD控制器的一个主要目标是实现损耗均衡，即是将P/E循环在块间尽可能的平均分配。理想上，所有的块会在同一时间达到P/E循环上限并耗尽。[\[12, 14\]][13]

为了达到最好的全局损耗均衡，SSD控制器需要明智的选择要写入的块，且可能需要在数个块之间移动，其内部的进程会导致写入放大的增加。因此，块的管理是在最大化损耗均衡和最小话写入放大之间的权衡。

制造商想出各种各样的功能来实现损耗均衡，例如下一节要讲的垃圾回收。

损耗均衡

因为NAND闪存单元会耗尽，FTL的一个主要目标是尽可能平均的将工作分配给各个闪存单元，这样使得各个块将会在同一时间达到他们的P/E循环限制而耗尽。

4.闪存转换层(FTL)

4.1 FTL存在的必要性

使用SSD如此容易的主要因素是其使用和HDD相同的主机接口。尽管一组逻辑块地址（LBA）的出现使其感觉像HDD的扇区一样可被复写，但其并非完全符合闪存的工作方式。因此需要一个额外的组件来隐藏NAND闪存的内部特征，并只向主机暴露一组LBA。这个组件称为闪存转换层（FTL），位于SSD控制器中。FTL很关键，并有两个主要的作用，逻辑块寻址和垃圾回收。

4.2逻辑块映射

逻辑块映射将来自主机空间的逻辑块地址（LBA）转换为物理NAND闪存空间的物理块地址（PBA）。为了访问速度，这个映射表保存在SSD的RAM中，并保存在闪存中以防电源故障。当SSD启动后，这个表从闪存中读出并在SSD的RAM中重建[\[1, 5\]][13]。

一个比较简单的方法是使用页级映射来将主机的所有逻辑页映射为物理页。这个映射方法提供了很大的灵活性，然而主要的缺点是映射表需要大量的内存，这会显著地增加生产成本。一个解决方案是使用块级映射不再对页，而是对块进行映射。假设一个SSD硬盘每个块有256个页。这表示块级映射需要的内存是页级映射的256分之一，这是内存使用的巨大优化。然而这个映射仍然需要保存在硬盘上以防掉电。同时，以防大量小更新的工作负载，无论页是否是满的，全部闪存块都会写入。这会增加写入放大并使得块级映射普遍低效[\[1, 2\]][13]。

页级映射和块级映射的折中其实是在性能和空间之间折中的一个表现。一些研究者试着在两个方面都能够最佳化，得到了称为“hybrid（混合）”的方法[\[10\]][13]。最普遍的是日志块映射，其使用了一种比较像日志结构文件系统的方法。输入的写操作按顺序写入日志块中。当一个日志块满了之后，将其和与其在相同逻辑块编号（LBN）的数据块合并到空块中。只需要维护少量的日志块，且允许以页粒度维护。而块级映射是以块粒度维护的。

下边的图5是对混合日志块FTL的一个简单的陈述，每个块有4个页。FTL处理4个写操作，都是页大小尺寸的写入。逻辑页编号5和9都被映射到LBN（逻辑块编号）=1，而LBN=1关联到物理块\#1000。最初，在逻辑块映射表中，LBN=1的所有物理页offset都是null，而日志块\#1000同样是完全空的。

第一个写入将b’写到LPN=5，这被日志块映射表解释到LBN=1，即为关联到PBN=1000（日志块\#1000）。因此页b’写到块\#1000的0号页中。映射用的元数据需要更新，为此，逻辑offset 1（随便举的例子）对应的物理offset从null改为0。

写入操作继续而映射元数据随之更新，当日志块\#1000完全填满，将其和对应为相同的逻辑块的数据块（本例中是\#3000）合并。这个数据可以从数据块映射表中读取，此表将逻辑块映射为物理块。合并操作的结果数据被写到新的空块中，本例中为\#9000。当这个工作做完了，块\#1000和\#3000可以被擦除成为空块，而块\#9000成为一个数据块。数据块映射表中LBN=1的元数据则从一开始的\#3000改为新的数据块\#9000.

一个值得注意的很重要的事情是，四个写操作只集中在两个LPN中。逻辑块方法在合并的过程中隐藏了b’和d’操作，直接使用更加新的b”和d”版本，使其能够更好的降低写入放大。最后，如果读命令请求一个最新更新但还没合并到数据块中的页，这个页将会在日志块中读取，否者将会在数据块中找到。这就是如图5中所示，读操作即需要读取日志块映射表又需要读取数据块映射表的原因。

![7cc829d3gw1efqfq8owefj20k00s1djy.jpg][]

图5：混合日志块FTL

日志块FTL可以进行优化，其最值得注意的是切换合并，有时候也叫做“交换合并”。假设逻辑块中所有地址都立马写满了，这表示这些地址的所有新数据都将写到一个像样的日志块中。既然这个日志块包含的数据是一整个逻辑块的数据，那么将其和数据块合并到新的空块中是没有意义的，因为保存合并结果的空块中的数据就是日志块中的数据。只更新数据块映射表中的元数据并将数据块映射表中的数据块切换为日志块将会更快，这就是切换合并。

很多论文都讨论日志块映射方案，这些论文导致了一系列的改进，例如FAST（Fully Associative Sector Translation 完全关联扇区转换）、superblock mapping（超块映射）、以及flexible group mapping（灵活组映射）。同样还有其他的映射方案，例如Mitsubishi（三菱）算法和SSR。下面两篇论文是学习更多关于FTL和映射方案的很好的开始点

*  “A Survey of Flash Translation Layer“, Chung et al., 2009 [\[9\]][13]
 *  “A Reconfigurable FTL (Flash Translation Layer) Architecture for NAND Flash-Based Applications“, Park et al., 2008 [\[10\]][13]

闪存转换层

闪存转换层是SSD控制器的一个组件，它将来自主机的逻辑块地址（LBA）映射为硬盘上的物理块地址（PBA）。大部分最新的硬盘使用了一种叫做“混合日志块映射”的技术或者其衍生技术，其工作方式比较像日志结构文件系统。这种技术可以将随机写入当做序列写入处理。

4.3 关于行业状态的注记.

在2014年2月2日，Wikipedia [\[64\]][13]上列出了70个SSD的生产商，有意义的是，只有11个主控的生产商[\[65\]][13]。在这11个主控生产商之中，只有4个是“captive（自给自足的）”，即仅对它们自己的产品使用自己的主控（譬如Intel和三星）；而其他的7个是“independent（独立的）”，即他们把自己的主控卖给其他的硬盘生产商。这些数字表示，这7个公司生产固态硬盘市场上90%的主控。

我没有这90%中，关于哪个主控生产商卖给哪个硬盘生产商的数据吗，但是根据帕雷托法则（二八定律或80/20法则——译注），我赌只有两三家主控制造商分享了大部分的蛋糕。直接结论是，来自非自给自足厂家的SSD，因其本质上使用相同的主控或至少其主控使用相同的全局设计和底层思想，其行为会及其相似。

映射方案作为主控的一部分是SSD十分重要的组件，因为其往往完全定义了硬盘的表现。这就解释了为什么在有如此多竞争的产业中，SSD主控生产商不分享其FTL实现的细节。因此，即使有大量的公共可用的关于FTL算法的研究，但仍然不清楚主控生产商使用了多少研究，以及某个牌子和型号具体实现了什么。

这篇文章[\[3\]][13]的作者声称通过分析工作负载，他们可以对硬盘的映射策略进行反向工程。除非芯片中的二进制代码本身被反向工程，我自己还是不太认同这种方法。因为没有办法完全确认某个硬盘中映射策略真正做了什么。并且预测一个特定的工作负载下映射的行为更难。

因为有很大量的不同映射策略，而对市场上所有可用固件进行反向工程所花费的时间的量值得考虑。然后，即使获得了所有可能的映射政策的源代码，你能拿来干啥？新产品的系统需求经常导致全面改进，使用未标明和内部易变的硬件组件。因此，只为一个映射政策进行优化是不值当的，因为这个优化的方案可能在其他所有映射政策表现很差。某人想只对一种映射政策进行优化的唯一原因是他在为已经保证使用一致硬件的嵌入式系统进行开发。

综上所述，我得说知道某一个SSD具体使用的是哪一个映射政策并不重要。唯一重要的事情是知道映射政策是LBA和PBA之间的转换层，而其很像混合日志块或其衍生算法的实现。因此，写入大小至少是NAND闪存块大小的数据片将会更加效率，因为对于FTL来说，更新映射及其元数据的开支是最小化的。

4.4 垃圾回收

如我在4.1和4.2节中所说，页不能被复写。如果页中的数据必须更新，新版本必须写到空页中，而保存之前版本数据的页被标记为stale。当块被stale页充满后，其需要在能够再写入之前进行擦除。

垃圾回收

SSD控制器中的垃圾回收进程确保“stale”的页被擦除并变为“free”状态，使得进来的写入命令可以访问这个页。

如第一节中所说，擦除命令需要1500-3500 μs，写入命令需要250-1500 μs。因为擦除比写入需要更高的延迟，额外的擦除步骤导致一个延迟使得写入更慢。因此，一些控制器实现了后台垃圾回收进程，或者被称为闲置垃圾回收，其充分利用空闲时间并经常在后台运行以回收stale页并确保将来的前台操作具有不足够的空页来实现最高性能[\[1\]][13]。其他的实现使用并行垃圾回收方法，其在来自主机的写入操作的同时，以并行方式进行垃圾回收操作。

遇到写入工作负载重到垃圾回收需要在主机来了命令之后实时运行的情况并非罕见。在这种情况下，本应运行在后台的垃圾回收进程可能会干预到前台命令[\[1\]][13]。TRIM命令和预留空间是减少这种影响的很好的方法，具体细节将在6.1和6.2节介绍。

后台操作可能影响前台操作

诸如垃圾回收后台操作可能会对来自主机的前台操作造成负面影响，尤其是在持续的小随机写入的工作负载下。

块需要移动的一个不太重要的原因是read disturb（读取扰乱）。读取可能改变临近单元的状态，因此需要再一定数量的读取之后移动块数据[\[14\]][13]。

数据改变率是一个很重要的影响因素。有些数据很少变化，称为冷数据或者静态数据，而其他一些数据更新的很频繁，称为热数据或者动态数据。如果一个页一部分储存冷数据，另一部分储存热数据，这样冷数据会随着热数据一起在垃圾回收以损耗均衡的过程中拷贝，冷数据的存在增加了写入放大。这可以通过将冷数据从热数据之中分离出来，存储到另外的页中来避免。缺点是这样会使保存冷数据的页更少擦除，因此必须将保存冷数据和热数据的块经常交换以确保损耗均衡。

因为数据的热度是在应用级确定的，FTL没法知道一个页中有多少冷数据和热数据。改进SSD性能的一个办法是尽可能将冷热数据分到不同的页中，使垃圾回收的工作更简单。

分开冷热数据

热数据是经常改变的数据，而冷数据是不经常改变的数据。如果一些热数据和冷数据一起保存到同一个页中，冷数据会随着热数据的读-改-写操作一起复制很多次，并在为了损耗均衡进行垃圾回收过程中一起移动。尽可能的将冷热数据分到不同的页中是垃圾回收的工作更简单

缓存热数据

极其热的数据应该尽可能多的缓存，并尽可能的少的写入到硬盘中。

以较大的量废除旧数据

当一些数据不再需要或者需要删除的时候，最好等其它的数据一起，在一个操作中废除一大批数据。这会使垃圾回收进程一次处理更大的区域而最小化内部碎片。

引用

\[1\] [Understanding Intrinsic Characteristics and System Implications of Flash Memory based Solid State Drives, Chen et al., 2009][Understanding Intrinsic Characteristics and System Implications of Flash Memory based Solid State Drives_ Chen et al._ 2009]  
\[2\] [Parameter-Aware I/O Management for Solid State Disks (SSDs), Kim et al., 2012][Parameter-Aware I_O Management for Solid State Disks _SSDs_ Kim et al._ 2012]  
\[3\] [Essential roles of exploiting internal parallelism of flash memory based solid state drives in high-speed data processing, Chen et al, 2011][Essential roles of exploiting internal parallelism of flash memory based solid state drives in high-speed data processing_ Chen et al_ 2011]  
\[4\] [Exploring and Exploiting the Multilevel Parallelism Inside SSDs for Improved Performance and Endurance, Hu et al., 2013][Exploring and Exploiting the Multilevel Parallelism Inside SSDs for Improved Performance and Endurance_ Hu et al._ 2013]  
\[5\] [Design Tradeoffs for SSD Performance, Agrawal et al., 2008][Design Tradeoffs for SSD Performance_ Agrawal et al._ 2008]  
\[6\] [Design Patterns for Tunable and Efficient SSD-based Indexes, Anand et al., 2012][Design Patterns for Tunable and Efficient SSD-based Indexes_ Anand et al._ 2012]  
\[7\] [BPLRU: A Buffer Management Scheme for Improving Random Writes in Flash Storage, Kim et al., 2008][BPLRU_ A Buffer Management Scheme for Improving Random Writes in Flash Storage_ Kim et al._ 2008]  
\[8\] [SFS: Random Write Considered Harmful in Solid State Drives, Min et al., 2012][SFS_ Random Write Considered Harmful in Solid State Drives_ Min et al._ 2012]  
\[9\] [A Survey of Flash Translation Layer, Chung et al., 2009][A Survey of Flash Translation Layer_ Chung et al._ 2009]  
\[10\] [A Reconfigurable FTL (Flash Translation Layer) Architecture for NAND Flash-Based Applications, Park et al., 2008][A Reconfigurable FTL _Flash Translation Layer_ Architecture for NAND Flash-Based Applications_ Park et al._ 2008]  
\[11\] [Reliably Erasing Data From Flash-Based Solid State Drives, Wei et al., 2011][Reliably Erasing Data From Flash-Based Solid State Drives_ Wei et al._ 2011]  
\[12\] [http://en.wikipedia.org/wiki/Solid-state\_drive][http_en.wikipedia.org_wiki_Solid-state_drive]  
\[13\] [http://en.wikipedia.org/wiki/Write\_amplification][http_en.wikipedia.org_wiki_Write_amplification]  
\[14\] [http://en.wikipedia.org/wiki/Flash\_memory][http_en.wikipedia.org_wiki_Flash_memory]  
\[15\] [http://en.wikipedia.org/wiki/Serial\_ATA][http_en.wikipedia.org_wiki_Serial_ATA]  
\[16\] [http://en.wikipedia.org/wiki/Trim\_(computing)][http_en.wikipedia.org_wiki_Trim_computing]  
\[17\] [http://en.wikipedia.org/wiki/IOPS][http_en.wikipedia.org_wiki_IOPS]  
\[18\] [http://en.wikipedia.org/wiki/Hard\_disk\_drive][http_en.wikipedia.org_wiki_Hard_disk_drive]  
\[19\][http://en.wikipedia.org/wiki/Hard\_disk\_drive\_performance\_characteristics][http_en.wikipedia.org_wiki_Hard_disk_drive_performance_characteristics]  
\[20\] [http://centon.com/flash-products/chiptype][http_centon.com_flash-products_chiptype]  
\[21\] [http://www.thessdreview.com/our-reviews/samsung-64gb-mlc-ssd/][http_www.thessdreview.com_our-reviews_samsung-64gb-mlc-ssd]  
\[22\] [http://www.anandtech.com/show/7594/samsung-ssd-840-evo-msata-120gb-250gb-500gb-1tb-review][http_www.anandtech.com_show_7594_samsung-ssd-840-evo-msata-120gb-250gb-500gb-1tb-review]  
\[23\] [http://www.anandtech.com/show/6337/samsung-ssd-840-250gb-review/2][http_www.anandtech.com_show_6337_samsung-ssd-840-250gb-review_2]  
\[24\] [http://www.storagereview.com/ssd\_vs\_hdd][http_www.storagereview.com_ssd_vs_hdd]  
\[25\][http://www.storagereview.com/wd\_black\_4tb\_desktop\_hard\_drive\_review\_wd4003fzex][http_www.storagereview.com_wd_black_4tb_desktop_hard_drive_review_wd4003fzex]  
\[26\][http://www.storagereview.com/samsung\_ssd\_840\_pro\_review][http_www.storagereview.com_samsung_ssd_840_pro_review]  
\[27\][http://www.storagereview.com/micron\_p420m\_enterprise\_pcie\_ssd\_review][http_www.storagereview.com_micron_p420m_enterprise_pcie_ssd_review]  
\[28\] [http://www.storagereview.com/intel\_x25-m\_ssd\_review][http_www.storagereview.com_intel_x25-m_ssd_review]  
\[29\][http://www.storagereview.com/seagate\_momentus\_xt\_750gb\_review][http_www.storagereview.com_seagate_momentus_xt_750gb_review]  
\[30\][http://www.storagereview.com/corsair\_vengeance\_ddr3\_ram\_disk\_review][http_www.storagereview.com_corsair_vengeance_ddr3_ram_disk_review]  
\[31\] [http://arstechnica.com/information-technology/2012/06/inside-the-ssd-revolution-how-solid-state-disks-really-work/][http_arstechnica.com_information-technology_2012_06_inside-the-ssd-revolution-how-solid-state-disks-really-work]  
\[32\] [http://www.anandtech.com/show/2738][http_www.anandtech.com_show_2738]  
\[33\] [http://www.anandtech.com/show/2829][http_www.anandtech.com_show_2829]  
\[34\] [http://www.anandtech.com/show/6489][http_www.anandtech.com_show_6489]  
\[35\] [http://lwn.net/Articles/353411/][http_lwn.net_Articles_353411]  
\[36\][http://us.hardware.info/reviews/4178/10/hardwareinfo-tests-lifespan-of-samsung-ssd-840-250gb-tlc-ssd-updated-with-final-conclusion-final-update-20-6-2013][http_us.hardware.info_reviews_4178_10_hardwareinfo-tests-lifespan-of-samsung-ssd-840-250gb-tlc-ssd-updated-with-final-conclusion-final-update-20-6-2013]  
\[37\] [http://www.anandtech.com/show/6489/playing-with-op][http_www.anandtech.com_show_6489_playing-with-op]  
\[38\][http://www.ssdperformanceblog.com/2011/06/intel-320-ssd-random-write-performance/][http_www.ssdperformanceblog.com_2011_06_intel-320-ssd-random-write-performance]  
\[39\][http://en.wikipedia.org/wiki/Native\_Command\_Queuing][http_en.wikipedia.org_wiki_Native_Command_Queuing]  
\[40\] [http://superuser.com/questions/228657/which-linux-filesystem-works-best-with-ssd/][http_superuser.com_questions_228657_which-linux-filesystem-works-best-with-ssd]  
\[41\] [http://blog.superuser.com/2011/05/10/maximizing-the-lifetime-of-your-ssd/][http_blog.superuser.com_2011_05_10_maximizing-the-lifetime-of-your-ssd]  
\[42\] [http://serverfault.com/questions/356534/ssd-erase-block-size-lvm-pv-on-raw-device-alignment][http_serverfault.com_questions_356534_ssd-erase-block-size-lvm-pv-on-raw-device-alignment]  
\[43\] [http://rethinkdb.com/blog/page-alignment-on-ssds/][http_rethinkdb.com_blog_page-alignment-on-ssds]  
\[44\] [http://rethinkdb.com/blog/more-on-alignment-ext2-and-partitioning-on-ssds/][http_rethinkdb.com_blog_more-on-alignment-ext2-and-partitioning-on-ssds]  
\[45\] [http://rickardnobel.se/storage-performance-iops-latency-throughput/][http_rickardnobel.se_storage-performance-iops-latency-throughput]  
\[46\] [http://www.brentozar.com/archive/2013/09/iops-are-a-scam/][http_www.brentozar.com_archive_2013_09_iops-are-a-scam]  
\[47\] [http://www.acunu.com/2/post/2011/08/why-theory-fails-for-ssds.html][http_www.acunu.com_2_post_2011_08_why-theory-fails-for-ssds.html]  
\[48\][http://security.stackexchange.com/questions/12503/can-wiped-ssd-data-be-recovered][http_security.stackexchange.com_questions_12503_can-wiped-ssd-data-be-recovered]  
\[49\][http://security.stackexchange.com/questions/5662/is-it-enough-to-only-wipe-a-flash-drive-once][http_security.stackexchange.com_questions_5662_is-it-enough-to-only-wipe-a-flash-drive-once]  
\[50\][http://searchsolidstatestorage.techtarget.com/feature/The-truth-about-SSD-performance-benchmarks][http_searchsolidstatestorage.techtarget.com_feature_The-truth-about-SSD-performance-benchmarks]  
\[51\][http://www.theregister.co.uk/2012/12/03/macronix\_thermal\_annealing\_extends\_life\_of\_flash\_memory/][http_www.theregister.co.uk_2012_12_03_macronix_thermal_annealing_extends_life_of_flash_memory]  
\[52\][http://www.eecs.berkeley.edu/~rcs/research/interactive\_latency.html][http_www.eecs.berkeley.edu_rcs_research_interactive_latency.html]  
\[53\] [http://blog.nuclex-games.com/2009/12/aligning-an-ssd-on-linux/][http_blog.nuclex-games.com_2009_12_aligning-an-ssd-on-linux]  
\[54\] [http://www.linux-mag.com/id/8397/][http_www.linux-mag.com_id_8397]  
\[55\] [http://tytso.livejournal.com/2009/02/20/][http_tytso.livejournal.com_2009_02_20]  
\[56\] [https://wiki.debian.org/SSDOptimization][https_wiki.debian.org_SSDOptimization]  
\[57\] [http://wiki.gentoo.org/wiki/SSD][http_wiki.gentoo.org_wiki_SSD]  
\[58\][https://wiki.archlinux.org/index.php/Solid\_State\_Drives][https_wiki.archlinux.org_index.php_Solid_State_Drives]  
\[59\][https://www.kernel.org/doc/Documentation/block/cfq-iosched.txt][https_www.kernel.org_doc_Documentation_block_cfq-iosched.txt]  
\[60\][http://www.danielscottlawrence.com/blog/should\_i\_change\_my\_disk\_scheduler\_to\_use\_NOOP.html][http_www.danielscottlawrence.com_blog_should_i_change_my_disk_scheduler_to_use_NOOP.html]  
\[61\] [http://www.phoronix.com/scan.php?page=article&item=linux\_iosched\_2012][http_www.phoronix.com_scan.php_page_article_item_linux_iosched_2012]  
\[62\] [http://www.velobit.com/storage-performance-blog/bid/126135/Effects-Of-Linux-IO-Scheduler-On-SSD-Performance][http_www.velobit.com_storage-performance-blog_bid_126135_Effects-Of-Linux-IO-Scheduler-On-SSD-Performance]  
\[63\] [http://www.axpad.com/blog/301][http_www.axpad.com_blog_301]  
\[64\] [http://en.wikipedia.org/wiki/List\_of\_solid-state\_drive\_manufacturers][http_en.wikipedia.org_wiki_List_of_solid-state_drive_manufacturers]  
\[65\][http://en.wikipedia.org/wiki/List\_of\_flash\_memory\_controller\_manufacturers][http_en.wikipedia.org_wiki_List_of_flash_memory_controller_manufacturers]  
\[66\] [http://blog.zorinaq.com/?e=29][http_blog.zorinaq.com_e_29]  
\[67\] [http://www.gamersnexus.net/guides/956-how-ssds-are-made][http_www.gamersnexus.net_guides_956-how-ssds-are-made]  
\[68\] [http://www.gamersnexus.net/guides/1148-how-ram-and-ssds-are-made-smt-lines][http_www.gamersnexus.net_guides_1148-how-ram-and-ssds-are-made-smt-lines]  
\[69\][http://www.tweaktown.com/articles/4655/kingston\_factory\_tour\_making\_of\_an\_ssd\_from\_start\_to\_finish/index.html][http_www.tweaktown.com_articles_4655_kingston_factory_tour_making_of_an_ssd_from_start_to_finish_index.html]  
\[70\] [http://www.youtube.com/watch?v=DvA9koAMXR8][http_www.youtube.com_watch_v_DvA9koAMXR8]  
\[71\] [http://www.youtube.com/watch?v=3s7KG6QwUeQ][http_www.youtube.com_watch_v_3s7KG6QwUeQ]  
\[72\] [Understanding the Robustness of SSDs under Power Fault, Zheng et al., 2013][Understanding the Robustness of SSDs under Power Fault_ Zheng et al._ 2013] — [\[discussion on HN\]][discussion on HN]  
\[73\] [http://lkcl.net/reports/ssd\_analysis.html][http_lkcl.net_reports_ssd_analysis.html] —[\[discussion on HN\]][discussion on HN 1]

# 为SSD编程（4）：高级功能和内部并行 #

在这个部分，我将简要的介绍固态硬盘（SSD）的一些主要功能，如TRIM和预留空间。还会介绍SSD中不同等级的内部并行。

5. 高级功能

5.1 TRIM

让我们假设一个程序向SSD所有的逻辑块地址都写入文件，这个SSD当然会被装满。然后删除这些文件。文件系统会报告所有的地方都是空的，尽管硬盘实际上还是满的，因为SSD主控没法知道逻辑数据是什么时候被主机删掉的。SSD主控只会在这些逻辑块地址被复写的时候才知道这些是空闲空间。此时，垃圾回收进程将会擦除与这些文件相关的块，为进来的写操作提供空的页。其结果就是，擦除操作并非在知道保存有无用数据之后立刻执行，而是被延迟了，这将严重影响性能。

另一个值得关心的是，既然SDD主控不知道这些页保存有已删除的文件，垃圾回收机制仍然会为了损耗均衡而移动这些页上的数据。这增加了写入放大，并毫无意义地影响了来自主机的前台工作负载。

延迟擦除问题的一个解决方法是TRIM命令，这个命令由操作系统发送，通知SSD控制器逻辑空间中的这些页不会再使用了。有了这个信息，垃圾回收进程就会知道自己不必再移动这些页，并可以在任何需要的时间擦除它们。TRIM命令只会在当SSD、操作系统和文件系统都支持的时候才起作用。

TRIM命令的维基百科页面列出了支持TRIM的操作系统和文件系统[\[16\]][16]。Linux下，ATA TRIM的支持是在2.6.33版本加入的。尽管ext2和ext3 文件系统不支持TRIM，ext4 和XFS以及其他的一些是支持的。在Mac OS 10.6.8下，HFS+支持TRIM操作。Windows 7则只支持使用SATA接口的SSD的TRIM，使用PCI-Express的则不支持。

现在大部分的硬盘都支持TRIM，确实，允许垃圾回收尽早的工作显著地提升了将来的性能。因此强烈建议使用支持TRIM的SSD，并确保操作系统和文件系统级都启用了TRIM功能。

5.2 预留空间

预留空间只是简单的使物理块比逻辑块多，即为主控保留一定比例的，用户不可见的物理块。大多专业级SSD生产商已经包括了一些预留空间，通常是7~25%[\[13\]][16]。用户可以简单的通过创建比最大物理容量小的逻辑容量分区来创建更多的预留空间。例如，你可以在100G的硬盘上创建一个90G的分区，而把剩下的10G作为预留空间。即使预留空间在操作系统级是不可见的，但SSD主控仍然是可以看见的。生产商提供预留空间的主要原因是为了对付NAND闪存单元固有的兽兽门限制。不可见的预留空间的块将无缝的替换可见空间上的已耗损殆尽的块。

AnandTech有一篇有意思的文章显示出预留空间对SSD寿命和性能的影响[\[34\]][16]。在他们研究的硬盘上，结果显示出仅通过保证25%的预留空间（把所有的预留空间加在一起）就可以使性能极大地提升。在Percona的一篇文章中有另外一个有意思的结果，在他们测试了一块Intel 320 SSD，显示出当硬盘逐渐填满时，写入吞吐量将随之下降[\[38\]][16]。

这里是我的实验中发生的事情。垃圾回收是使用空闲时间在后台擦除页上不再使用的数据的。但既然擦除操作比写入操作的延迟更久，或者说擦除要的时间比写入长，在持续的重随机写入工作负载下的SSD将会在垃圾回收有机会擦除之前用尽所有的空块。此时，FTL将不能跟上前台的随机写入工作负载，而垃圾回收进程将必须在写入命令进来的同时擦除块。这就是在基准测试中SSD性能下降的厉害，而SSD显得性能超差的时候，如下图7所示。因此，预留空间可以吸收高吞吐量写入负载，起到缓冲的作用，为垃圾回收跟上写入操作并重新开始擦除无用块留够时间。预留空间需要多少大部分基于SSD使用环境的工作负载，和其需要的承受的写入操作的量。作为参考，持续随机写入的工作负载比较推荐使用大约25%的预留空间[\[34\]][16]。如果工作负载不是很重，大概10~15%估计够大的了。

预留空间对损耗均衡和性能表现是有用的

SSD可以简单地通过格式化时设置比最大物理容量小的逻辑容量来启动预留空间。余下的不被用户所见的空间仍会被SSD主控所用。预留空间帮助损耗均衡机制来对付NAND闪存单元的寿命限制。对于写入不是很重的工作负载，10~15%的预留空间足够了。对于持续的随机写入工作负载，保持25%的预留空间将会提升性能。预留空间将会扮演NAND闪存块的缓冲区的角色，帮助垃圾回收进程吸收写入峰值。

从此，同样可以推导出，预留空间甚至可能为不支持TRIM命令的环境提供更大的性能提升——注意我只是在这进行个假设，我仍然在寻找材料来支持这个观点。假设只有75%的硬盘空间可被操作系统使用，余下的25%留作预留空间。因为SSD控制器可以看见整个硬盘，尽管在某一时刻只有75%的物理NAND闪存被使用，但100%的块都在已使用、已废弃、已擦除三种状态中交替转换。这表示余下的25%物理闪存将可以安全的认为没有保存有数据，因为其并没有被映射到任何逻辑块地址上。因此，即使不支持TRIM，垃圾回收进程也能够提前擦除这些预留空间中块。

5.3 安全擦除

一些SSD主控提供ATA安全擦除功能，其作用是当硬盘处于意料之外的状态时恢复其性能。这个命令擦除所有用户写入的数据并重置FTL映射表，但这显然不能克服P/E循环有限造成的物理限制。尽管其功能上看上去非常有前途，但需要每个生产商争取的实现它。Wei等人2011年在他们关于安全擦除命令的review中显示，在他们研究的超过12个型号SSD中，只有8个提供了ATA安全擦除功能，而在这8个硬盘中，三个都有各种bug[\[11\]][16]。

对于性能的影响是很重要的，并且在安全方面更加重要，但我不想展开说。这里有几个Stack Overflow上的讨论可以解释关于如何可靠地删除SSD中的数据的细节。

5.4 原生命令队列(NCQ)

原生命令队列（NCQ）是SATA的一个功能，其允许SSD接受来自主机的多个命令，使SSD可以使用内部并行同时完成这些命令[\[3\]][16]。除了减少因为硬盘造成的延迟外，一些新的硬盘同样使用NCQ来应对来自主机的延迟。例如NCQ可以优先传入的命令来确保当主机CPU忙的时候硬盘总是有命令处理。

5.5 断电保护

无论是在家还是在数据中心，断电都是有可能发生的。一些生产商在他们的SSD结构中设置有超级电容，这个电容设计为存有足够提交总线中所有I/O请求所需的能量以防掉电。问题在于并非所有的SSD生产商都为他们的硬盘设置超级电容或者某种掉电保护，而有超级电容的不总是在说明书中提及。然后，和安全擦除命令一样，断电保护机制的实现是否正确，并且是否确实能够在掉电时避免数据损坏是搞不清楚的。

Zheng等人2013年的研究中测试了15个SSD，但没有透露品牌[\[72\]][16]。他们给硬盘各种各样的电源故障，发现测试的15个SSD中有13个最终丢失数据或者大规模的数据损坏。在另外一篇Luke Kenneth Casson Leighton写的关于电源故障的文章中显示出，测试的4个硬盘有3个最终都在不正确的状态，剩下的一个没有问题（是Intel的硬盘）[\[73\]][16] 。

SSD还是一个非常年轻的技术，并且我相信这些电源故障下造成数据损坏的阻力将会在接下来的产品中克服。然而现在，在数据中心配置不间断电源（UPS）可能还是应该做的。并且和任何其他存储解决方案一样，经常备份敏感数据。

6.SSD中的内部并行

6.1 总线带宽限制

因为物理限制的存在，异步NAND闪存I/O总线无法提供32-40 MB/s以上的带宽[\[5\]][16]。SSD生产商提升性能的唯一办法是以某种方法让他们的硬盘中的多个存储芯片可以并行或者交错。[\[2\]][16]的2.2节中有一个比较好的关于交错的解释。

通过组合SSD内所有层次的内部并行，不同芯片中的多个块可以作为一个叫clustered block（直译是集群块，但我感觉用簇比较亲切，本译文中所有的簇都是指它）东西同时访问。我不打算解释关于SSD内部并行的所有细节，因此我只简述一下并行的层次和簇。获取更多关于这个话题的信息，以及SSD内部并行的概括，这里的两篇论文是很好的开始[\[2, 3\]][16]。此外，一些高级命令如copyback和inter-plane transfer在[\[5\]][16]中有阐述。

内部并行

在SSD内部，数个层次的并行允许一次将数个块写入到不同的NAND闪存芯片中，这些块称为簇。

6.2 并行的多级别

下边的图6展示了NAND闪存芯片的内部，其组织为一种分级的结构。这些级别包括通道、封装、芯片、面、块和页。如[\[3\]][16]中揭示的，这些不同的层通过下边的方法提供并行

*  通道级并行 闪存主控和闪存封装之间的通信通过数个通道。这些通道可以独立或者同时访问。每个独立通道有数个封装共享。
 *  封装级并行 一个通道中的不同封装可以独立访问。交错可以使命令同时在同一个通道中的不同封装中运行。
 *  芯片级并行 一个封装包含两个或者更多的芯片，芯片可以并行独立访问。注：芯片通常也被称为核心（chips are also called “dies”）
 *  面级并行 一个芯片包含两个或者更多的面。相同的操作（读、写或者擦除）可以在芯片中多个面上同时运行。面包含了块，块包含了页。面也包含了寄存器（小RAM缓存），其用在面级操作上。

![7cc829d3gw1eg9igt3kjqj20k00o3ju7.jpg][]

图6: NAND 闪存封装

6.3 簇

译注： 本节标题原文是“clustered blocks”，词典上没有这个词（词组？），Google了也没有发现合适的翻译，其直译是“集群的块”或者“成簇的块”。因为这个“clustered blocks”和“簇”的英文“Data cluster”比较像，特性上也相似（都是若干存储单位的集合），决定将这个“clustered blocks”在本文中译为“簇”。但这个簇与机械硬盘的簇不是相同的东西，请读者注意分辨。如果有更为合适或者正规的翻译请告诉我。

从多个芯片中访问到的多个块被称为一个簇[\[2\]][16]。这个做法比较像RAID系统中的striping[\[1, 5\]][16]。

一次访问的逻辑块地址被分到不同SSD闪存封装中的不同芯片上。这归功于FTL的映射算法，并且这与这些地址是否连续无关。分割块允许同时使用多个通道来整合其带宽，并同样可以并行执行多个读、写和擦除操作。这即表示I/O操作按簇大小对齐来确保SSD中多个级别的内部并行所提供的性能能够最大程度的利用。

# 为SSD编程（5）：访问模式和系统优化 #

在之前的章节中我叙述了固态硬盘大部分的内部工作，我可以提供数据来帮助理解应该使用哪种访问模式一起为何这种模式确实比其它的好。在这个部分，我解释了写入和读取是如何完成的，以及并发的写入和读取会相互干扰。我同样介绍了文件系统级可以提升性能的一点优化方法。

![7cc829d3gw1egyxsils2tj20k00g3go1.jpg][]

### 7. 访问模式 ###

#### 7.1 定义顺序和随机I/O操作 ####

在接下来的部分，我打算从“顺序”或“随机”入手。如果I/O操作开始的逻辑块地址（LBA）直接跟着前一个I/O操作的最后LBA，则称值为顺序访问。如果不是这样，那这个I/O操作称为随机访问。这很一点重要，因为FTL执行动态映射，相邻的逻辑空间地址可能被应用于不相邻的物理空间地址上。

#### 7.2 写入 ####

基准测试和生产商提供的数据表显示出，随机写入比序列写入要慢，但这并不总是对的，因为随机写入的速度实际上取决于工作负载的类型。如果写入比较小，小是说小于簇（译注：关于簇的翻译请见上一篇文章）大小（就是说 <32MB），那么是的，随机写入比顺序写入慢。然而，如果随机写入是按照簇大小对齐的，其性能将会和顺序写入一样。

解释如下。如第六节所说，SSD的内部并行机制通过并行和交错，允许簇中的块同时访问。因此，无论是随机或者序列写入，都会同样将数据写入到多个通道和芯片上，从而执行簇大小的写入可以确保全部的内部并行都用上了。簇上的写入操作将在后边的7.3节解释。至于性能，如来自 [\[2\]][2]和 [\[8\]][2] 的图8和图9所示。当基准测试写入缓存和簇大小（大部分SSD是16或32MB）相同或者更大时，随机写入达到和顺序写入同样高的吞吐量。

![7cc829d3gw1egyxskiqvyj20k00h9wgb.jpg][]

图8：4块SSD顺序写入负载和随机写入负载效率对照——根据Kim et al., 2012 [\[2\]][2] 重制

![7cc829d3gw1egyxsma5avj20k00d8ac6.jpg][]

图9：3块SSD顺序写入负载和随机写入负载效率对照——根据Min et al., 2012 [\[8\]][2]重制

然而，如果是小写入——小是指比NAND闪存页小，就是说<  16 KB——主控需要做更多的工作以维护用来做块映射的元数据上。确实，一些SSD使用树形的数据结构来实现逻辑块地址和物理块地址之间的映射[\[1\]][2]，而大量小随机写入将转换成RAM中映射的大量更新。因为这个映射表需要在闪存中维护[\[1, 5\]][2]，这将导致闪存上的大量写入。而顺序工作负载只会导致少量元数据的更新，因此闪存的写入较少。

随机写入并不总是比顺序写入慢

如果写入很小（就是说比簇大小要小），随机写入将比顺序写入慢。如果写入是按簇大小对齐，随机写入将使用所有可用层级上的内部并行，并显示出和随机写入相同的性能。

另外一个原因是，如果随机写入很小，其将在块中引起大量的复制-擦除-写入操作。另一方面，大于等于块大小的顺序写入可以使用更快的交换合并优化操作。再者，小随机写入显然会有随机的无效数据。大量的块将只有一页是无效的，而非只有几个块全部无效，这样会导致作废的页将遍布物理空间而非集中在一起。这种现象被称为内部碎片，并导致清除效率下降，垃圾回收进程通过请求大量的擦除操作才能创建空页。

最后关于并发性，已有的研究已经显示出，单线程写入大数据和用很多并非线程写入大量小数据是一样快的。确实，大写入可以确保SSD所有的内部并行都用上了。因此试着实现并发的多个写入并不会提高吞吐量[\[1, 5\]][2]。然而，多并行写入和单线程访问相比将会有延迟[\[3, 26, 27\]][2]。

一个单一的大写入比很多小的并发写入要好

单一的大写入请求和很多小并发写入请求相比，表现出相同的吞吐量，但会导致延迟。单一的大写入比并发写入在响应时间上表现的更好。因此，只要可能，最好使用大写入，

当写入小并且没有经过组织或缓存，多线程比较好

很多并发的小写入请求将比单一的小写入请求提供更好的吞吐量。因此如果I/O比较小并不能整合到一起，最好是使用多线程。

#### 7.3 Reads 读取 ####

读取比写入要快。无论是顺序读取还是随机读取，都是这样。FTL是逻辑块到物理块地址的动态映射，并且将写入分布到各个通道上。这个方法有时候被称为“基于写入顺序的”映射[\[3\]][2]。如果数据是以和原本写入的顺序完全不相关，完全随机读取的，那就无法保证连续的读取分布在不同的通道。甚至有可能连续的随机读取访问的是同一个通道中的不同块，因此无法从内部并行中获取任何优势。Acunu写了一篇博文讲了这个情况，至少在他们测试的硬盘上是这样，读取性能和读取访问模式与数据原始写入方式有多相似直接挂钩[\[47\]][2]。

为了提升读取性能，将相关数据写在一起

读取性能由写入模式决定。当大块数据一次性写入时，其将被分散到不同的NAND闪存芯片上。因此你应该将相关的数据写在相同的页、块、或者簇上，这样稍后你可以利用内部并行的优势，用一个I/O访问较快的读取。

下面的图10表示出一个有两个通道4块芯片，每块芯片只有一个面的SSD。注意这技术上是不成立的，因为SSD每块芯片都有两个以上的面，但为了保持图片简洁，我决定只让每块芯片只有一面。大写字母代表大小和NAND闪存块相同的数据。图10上边的操作是顺序写入4个块：\[A B C D\]，在这个例子里刚好是一个簇的大小。写操作通过并行和交错被分配到四个面上使其更快。即便4个块在逻辑块地址上是连续的，但他们存储在四个不同的面中。

基于写入顺序的FTL，面上所有的块被选作写入操作的可能是近乎于相同的，因此簇不必由各自面上相同物理块地址（PBN）的块组成。在图10的例子中，第一个簇由四个不同面上的块组成，各自面上的PBN分别是1, 23, 11, 和51。

图10下边有两个读取操作，\[A B E F\] 和 \[A B G H\]。对于\[A B E F\]来说，A和E在同一个面上，这使其必须只从一个通道的两个面上读取。对于\[A B G H\]来说，A、B、G、和H存储在四个不同的面上，因此\[A B G H\]能够同时从两个通道的四个面上读取。从更多的面和通道上读取可以从内部并行上获得更多的优势，从而有更好的读取性能。

![7cc829d3gw1egyxsoenuej20k00w6431.jpg][]

图10： 利用SSD的内部并行

内部并行的一个直接结果是，使用多线程同时读取数据不是提升性能所必须的。实际上，如果这些并不知道内部映射的线程访问这些地址，将无法利用内部并行的优势，其可能导致访问相同的通道。同时，并发读取线程可能影响SSD预读能力（预读缓存）[\[3\]][2]。

一个单一的大读取比很多小的并发读取要好

并发随机读取不能完全使用预读机制。并且，多个逻辑块地址可能被映射到相同的芯片上，不能利用内部并行的优势。再者，一个大的读取操作会访问连续的地址，因此能够使用预读缓存（如果有的话）。因此，进行大读取请求更加可取。

SSD生产商通常不说页、块和簇的大小。但可以通过运行简单的工作负载来进行反向工程获取大部分SSD的基础特征[\[2, 3\]][2]。这些信息可以用在优化读写操作的缓存大小上，同时可以在格式化硬盘的时候使得分区与SSD内部特征对齐，如8.4节中所说。

#### 7.4 并发读写 ####

小的读和写交错会导致性能下降[\[1, 3\]][2]。其主要原因是对于同一个内部资源来说读写是相互竞争的，而这种混合阻止了诸如预读取机制的完全利用。

分离读写请求

混合了小读取和小写入的工作负载将会阻止内部缓存和预读取机制的正常工作，并导致吞吐量下降。最好是能够避免同时的读写，并以一个一个的较大的数据块来进行，最好是簇的大小。例如，如果必须更新1000个文件，你可以遍历这些文件，对每个文件进行读和写然后移动到下一个文件，但这将会很慢。如果一次读取全部1000个文件然后一次写入1000个文件会更好。

### 8. 系统优化 ###

#### 8.1 分区对齐 ####

如3.1节中解释的那样，写入是页对齐的。大小是页大小，并且和页大小是对齐的写入请求，会被直接写入到一个NAND闪存物理页中。大小是页大小，但不对齐的写入请求将会被写入到两个个NAND闪存物理页中，并导致两个读-改-写操作[\[53\]][2]。因此，确保用来写入的SSD分区是和硬盘采用的物理NAND闪存页的大小对齐是很重要的。很多教程和指引都讲了格式化的时候如何将分区对齐SSD的参数[\[54, 55\]][2]。稍微Google一下就能知道某型号的SSD的NAND闪存页、闪存块和簇的大小。就算是没法拿到这些信息，通过一些反向工程也可以揭示出这些参数[\[2, 3\]][2]。

有人指出分区对齐可以显著地提高性能[\[43\]][2]。还有人指出，在对某块硬盘的测试中，绕过文件系统对硬盘直接进行写入会提高性能，不过提高很小[\[44\]][2]。

分区对齐

为了确保逻辑写入真的是和物理存储是对齐的，必须将分区和硬盘的NAND闪存页大小对齐。

#### 8.2 文件系统参数 ####

如5.1节所说，并不是所有的文件系统都支持TRIM命令[\[16\]][2]。Linux 2.6.33及以上，ext4和XFS支持TRIM，但仍需要使用discard参数来启用。此外，还有一些其它的微调，如果没有什么东西需要的话，可以通过移除relatime参数并添加noatime, nodiratime [\[40, 55, 56, 57\]][2] 将元数据的更新关掉。

启用TRIM命令

确认你的核心和文件系统支持TRIM命令。当某个块被删除的时候，TRIM命令会通知SSD主控。垃圾回收进程可以在闲的时候后台擦除这些块，为面对大写入工作负载准备硬盘。

#### 8.3 操作系统I/O调度器 ####

Linux上的默认I/O调度器是CFQ调度器（Completely Fair Queuing 完全公平队列）。CFQ被设计用来通过将物理上接近的I/O请求组合到一起从而最小化机械硬盘寻道时间的。这种请求重新排序对于SSD是 不必要的，因为它们没有机械部分。几个指引和讨论文章主张将I/O调度器从CFQ换为NOOP或Deadline将会减少SSD的延迟[\[56, 58\]][2]。然而子Linux 3.1版之后，CFQ为固态硬盘提供了一些优化[\[59\]][2]。基准测试同样显示出调度器的性能取决于应用在SSD上的工作负载（即应用），和硬盘自身[\[40, 60, 61, 62\]][2]。

我个人从中学到的是，除非工作负载十分特殊并且特定应用的基准测试显示出某个调度器确实比另一个好，CFQ是一个比较安全的选择。

#### 8.4 交换分区 ####

因为相当数量的I/O请求是由向硬盘上进行页交换导致的，SSD上的交换分区会增加损耗并显著降低寿命。在Linux内核，vm.swappiness参数控制想硬盘交换页的频率。其可用值是0到100，0表示内核需要尽可能的避免交换。以Ubuntu来说，默认swappiness是60。当使用SSD的时候，尽可能降低这个值（就是说设为0）会避免不必要的向硬盘的写入并增加其寿命[\[56, 63\]][2]。一些教程建议设置为1，而在实践中实际上和0一样的[\[57, 58\]][2]。

另外的做法的使用内存作为交换分区，或者完全避免使用交换分区。

#### 8.5 临时文件 ####

所有临时文件和日志文件没有必要，否则只是浪费SSD的生命周期。一些可以保存在RAM中的文件可以使用tmpfs文件系统[\[56, 57, 58\]][2]。

# 为SSD编程（6）：总结—每个程序员都应该了解的固态硬盘知识 #

在这部分，我以独立的简单段落的形式总结了其它部分的内容。每个段落概括了其他部分一节或几节的内容，这样可以让读者在每个主题下能够得到更多细节。

## 基础 ##

### 1. 存储单元类型 ###

固态硬盘（SSD）是基于闪存的数据存储设备。每个比特都存储在存储单元中，而存储单元分为三类：每个单元1比特（单层单元，SLC），每个单元2比特（多层单元，MLC），每个单元3比特（三层单元，TLC）。

[>> 详见第1.1节][Link 6]

### 2. 寿命限制 ###

每个单元都有P/E（写/擦）循环的最大限制，在此之后存储单元被认为是损坏的。这表示NAND闪存已经损耗殆尽，并有一个寿命限制。

[>> 详见第1.1节][Link 6]

### 3. 基准测试很难 ###

测试者是人，因此并不是所有的基准测试都毫无破绽。在读生产商或者第三方的基准测试结果的时候请小心，并在相信这些数据之前使用多个来源的数据。在有可能的时候，使用你的系统特定的工作负载在你打算使用的SSD型号上，运行自己的内部基准测试。最后，着眼于与你的系统最相关的性能指标。

[>> 详见第2.2节和第2.3节][SSD]

## 页和块 ##

### 4. NAND闪存页和块 ###

闪存单元组织成为阵列，称为块，而块组织成为面。块中能够进行读写操作的最小单元是页。页不能独立擦除，只能整块擦除。NAND闪存页大的大小并不一致，大多数硬盘的页大小是2KB、4KB、8 KB 或16 KB。大多数SSD每个块有128或256个页。这即表示一个块的大小可能在256 KB 到4 MB之间。例如Samsung SSD 840 EVO的块大小是2048 KB，每块包括256页每页8KB。

[>> 详见第3.2节][Link 7]

### 5. 读是页对齐的 ###

一次读取少于一页是不可能的。当然可以通过操作系统只请求一个字节，但SSD中会取回整个页，强制读取比所需多的多的数据。

[>> 详见第3.2节][Link 7]

### 6. 写是页对齐的 ###

写入到SSD的时候，写入将补齐到页大小。所以即便写入操作只影响一字节，都会重写整个页。写入比所需更多的数据被称为写入放大。写入一个页也被称为“（编置to program）”一个页。

[>> 详见第3.2节][Link 7]

### 7.页不能覆写 ###

NAND闪存页只能在其为“空”的状态下进行写入。当数据改变，页的内容被复制到内部寄存器中，数据更新，然后新版本的数据将存储字啊一个”空“页中，这个操作被称为”读-改-写“。数据并非原地更新，因为”空”页并非原先存储数据的页。一旦数据被保存到硬盘上，原来的页将被标记为“废弃”，并一直保持这样直到被擦除。

[>> 详见第3.2节][Link 7]

### 8.擦除是块对齐的 ###

页不能被覆写，一旦页成为“废弃的”，让其重新空下来的方法是擦除它们。然而，独立擦除一个页是不可能的，并且只能一次擦除整个块。

[>> 详见第3.2节][Link 7]

## 主控和内部 ##

### 9.闪存转换层 ###

闪存转换层（FTL）是SSD主控中的一个组件，它将来自主机的逻辑块地址（LBA）映射为硬盘上的物理块地址（PBA）。很多最新的硬盘使用了类似于“混合日志块”或其派生者的技术，其以类似于日志结构文件系统的方式工作。这允许将随机写入当做顺序写入处理。

[>> 详见第4.2节][Link 7]

### 10.内部并行 ###

在内部，数个层次的并行使得可以一次向不同NAND闪存芯片上写数个块的数据，这几个块被称为“簇”。

[>> 详见第6节][Link 8]

### 11.损耗均衡 ###

因为NAND闪存单元会损耗殆尽，FTL的一个主要目标是额能的将工作分散到各个单元上，这样块中的闪存单元可以在同一时间损坏。

[>> 详见第3.4节][Link 7]

### 12.垃圾回收 ###

SSD主控中的垃圾回收确保废弃的块能够擦除并重新变为空状态，使新进入的写入命令可以访问。

[>> 详见第4.4节][Link 7]

（译注：你没看错，少了13，原文就是这样）

### 14.后台操作可能影响前台操作 ###

例如垃圾回收的后台操作可能对来自主机的前台操作有负面影响，尤其是在持续的小随机写入工作负载下。

[>> 详见第4.4节][Link 7]

访问模式

### 15.绝不写入少于一页的数据 ###

避免写入少于NAND闪存页大小的数据以最小化写入放大并避免读-改-写操作。目前一页最大为16KB，因此此值应该作为默认值使用。这个值取决于SSD型号，并且在将来SSD改进之后你可能需要增加。

[>> 详见第3.2和3.3节][Link 7]

### 16.对齐写入 ###

将写入对齐为页大小，写入数据块大小为页大小的倍数。

[>> 详见第3.2和3.3节][Link 7]

### 17.小写入缓存化 ###

为了最大化吞吐量，在任何可能的时候将小写入缓存到内存中，当缓存满了再进行一次大写入，这样来将小写入打包。

[>> 详见第3.2和3.3节][Link 7]

### 18.为了提升读性能，将相关的数据写在一起。 ###

读取性能取决于写入模式。当大数据块一次写入的时候，其将被分配到不同的NAND闪存芯片上。因此你需要将相关的数据写到相同的页、块、或簇上，这样在你之后读取的时候可以利用内部并行，用一个I/O请求更快的读取。

[>> 详见7.3节][_7.3]

### 19.分离读写请求 ###

混合的小读写交叉的工作负载会妨碍内部缓存和预读取机制正常工作，并会导致吞吐量下降。最好的办法是避免同时发生的读操作和写操作，并将其以一个接一个的大数据块的形式实现，数据块大小推荐和簇大小相同。举个例子，如果要更新1000个文件，你可以遍历文件逐一读写，但会很慢。如果一次读取1000个文件然后一次写回1000个文件将会好很多。

[>> 详见7.4节][_7.3]

### 20.批量废弃数据 ###

当有数据不再需要或者需要删除的时候，最好等到废弃数据量比较大的时候在一个操作中统一废弃它们。这可以使垃圾回收进程可以一次处理更大范围的数据，可以最小化内部碎片。

[>> 详见第4.4节][Link 7]

### 21.随机写入并不远总是比顺序写入慢 ###

如果写入很小（即小于簇大小）。随机写入将比顺序写入慢。如果写入都是数倍于且对齐簇大小的话，随机写入将会利用所有可用层次的内部并行，并达到和顺序写入相同的水平。对于大部分硬盘来说，簇大小是16或32MB，因此使用32MB应该是安全的。

[>> 详见第7.2节][_7.3]

### 22.一个大的单线程的读取比很多小的并发读取要好 ###

并发随机读取不能完全使用预读取机制。并且，多个逻辑块地址会指向同一个芯片而不能利用内部并行。一个大的书签操作将会访问连续地址并在预读取缓存可用的时候利用之，并使用内部并行。因此如果用例允许的话，发出一个大的读取请求会好一些。

[>> 详见第7.3节][_7.3]

### 23.一个大的单线程写入比很多小的并发写入要好 ###

大的单线程写入请求提供的吞吐量和很多并发写入是相同的，然而就延迟来说，一个大的单一写入比并发写入反应时间要短一些。因此，在可用的时候，使用单线程大写入是最好的。

[>> 详见7.2节][_7.3]

### 24.当写入小且无法缓存或组织在一起的时候，多线程是有用的。 ###

很多并发写入请求将比单一小写入请求提供的吞吐量要大。因此，如果I/O很小并且不能组织，用多线程比较好。

[>> 详见第7.2节][_7.3]

### 25.分离冷热数据 ###

热数据是经常改变的数据，而冷数据是不经常改变的数据。如果一些热数据和冷数据被保存在同一个页中，冷数据将会随着热数据的每次读-改-写操作一起复制，并且会因为垃圾回收的损耗均衡不停移动位置。尽可能的将冷热数据分离到不同的也中将减轻垃圾回收的工作。

[>> 详见4.4节][Link 7]

### 26.缓存热数据 ###

极其热的速进和其他高频变化的元数据应该尽可能的缓存并尽可能少的写入硬盘。

[>> 详见4.4节][Link 7]

## 系统优化 ##

### 27. PCI Express 和SAS比SATA快 ###

生产商提供的两个主要的接口是SATA 3.0 (550 MB/s) 和 PCI Express 3.0 (1 GB/s 每通道，使用多个通道)。串行SCSI（SAS）同样在企业级的SSD上可用。在最新版本中，PCI Express和SAS比SATA要快，但也更贵。

[>> 详见2.1节][SSD]

### 28.预留空间对提高性能和损耗均衡十分有用 ###

硬盘可以简单地通过在格式化的时候让逻辑分区容量比最大物理容量小来设置预留空间。预留的空间对用户不可见，但SSD主控仍然可见。预留空间帮助损耗均衡机制应付NAND闪存单元固有的寿命限制。对于写入负载不是很重的工作环境，10%~15%的预留空间足够了。对于持续随机写入的工作负载，保持25%的工作负载将会提升性能。预留空间将会扮演NAND闪存块的缓存的角色，帮助垃圾回收进程吸收写入峰值。

[>> 详见5.2节][Link 8]

### 29.启用TRIM命令 ###

确认你的系统内核和文件系统支持TRIM命令。TRIM命令在块被删除的时候通知SSD主控。当垃圾回收进程能够在空闲时候后台擦除这些块，为将来的写入负载准备硬盘。

[>> 详见第5.1节][Link 8]

### 30.对齐分区 ###

为了确保逻辑写入确实和物理存储设备对齐，你需要将分区和硬盘的NAND闪存页对齐。

[>> 详见第8.1节][_7.3]

## 总结 ##

这是为“SSD编程”系列文章的总结。我希望我用易于理解的方法表述了我在固态硬盘上的个人研究中学到的东西。

如果你读了这个系列并想深入了解SSD，比较好的起步点是读一些我在第二部分和第五部分列出的引用文献和文章。

另外一个很好的学习资源是FAST大会（the USENIX Conference on File and Storage Technologies，USENIX文件和存储技术大会）。会上每年都有大量出色的研究。我高度推荐他们的网站，[FAST 2013][]视频和文献的集散地。（译注：截至本文翻译完毕， [FAST 2014][]的网站已经可用了。）

## References ##

\[1\] [Understanding Intrinsic Characteristics and System Implications of Flash Memory based Solid State Drives, Chen et al., 2009][Understanding Intrinsic Characteristics and System Implications of Flash Memory based Solid State Drives_ Chen et al._ 2009]  
\[2\] [Parameter-Aware I/O Management for Solid State Disks (SSDs), Kim et al., 2012][Parameter-Aware I_O Management for Solid State Disks _SSDs_ Kim et al._ 2012]  
\[3\] [Essential roles of exploiting internal parallelism of flash memory based solid state drives in high-speed data processing, Chen et al, 2011][Essential roles of exploiting internal parallelism of flash memory based solid state drives in high-speed data processing_ Chen et al_ 2011]  
\[4\] [Exploring and Exploiting the Multilevel Parallelism Inside SSDs for Improved Performance and Endurance, Hu et al., 2013][Exploring and Exploiting the Multilevel Parallelism Inside SSDs for Improved Performance and Endurance_ Hu et al._ 2013]  
\[5\] [Design Tradeoffs for SSD Performance, Agrawal et al., 2008][Design Tradeoffs for SSD Performance_ Agrawal et al._ 2008]  
\[6\] [Design Patterns for Tunable and Efficient SSD-based Indexes, Anand et al., 2012][Design Patterns for Tunable and Efficient SSD-based Indexes_ Anand et al._ 2012]  
\[7\] [BPLRU: A Buffer Management Scheme for Improving Random Writes in Flash Storage, Kim et al., 2008][BPLRU_ A Buffer Management Scheme for Improving Random Writes in Flash Storage_ Kim et al._ 2008]  
\[8\] [SFS: Random Write Considered Harmful in Solid State Drives, Min et al., 2012][SFS_ Random Write Considered Harmful in Solid State Drives_ Min et al._ 2012]  
\[9\] [A Survey of Flash Translation Layer, Chung et al., 2009][A Survey of Flash Translation Layer_ Chung et al._ 2009]  
\[10\] [A Reconfigurable FTL (Flash Translation Layer) Architecture for NAND Flash-Based Applications, Park et al., 2008][A Reconfigurable FTL _Flash Translation Layer_ Architecture for NAND Flash-Based Applications_ Park et al._ 2008]  
\[11\] [Reliably Erasing Data From Flash-Based Solid State Drives, Wei et al., 2011][Reliably Erasing Data From Flash-Based Solid State Drives_ Wei et al._ 2011]  
\[12\] [http://en.wikipedia.org/wiki/Solid-state\_drive][http_en.wikipedia.org_wiki_Solid-state_drive]  
\[13\] [http://en.wikipedia.org/wiki/Write\_amplification][http_en.wikipedia.org_wiki_Write_amplification]  
\[14\] [http://en.wikipedia.org/wiki/Flash\_memory][http_en.wikipedia.org_wiki_Flash_memory]  
\[15\] [http://en.wikipedia.org/wiki/Serial\_ATA][http_en.wikipedia.org_wiki_Serial_ATA]  
\[16\] [http://en.wikipedia.org/wiki/Trim\_(computing)][http_en.wikipedia.org_wiki_Trim_computing]  
\[17\] [http://en.wikipedia.org/wiki/IOPS][http_en.wikipedia.org_wiki_IOPS]  
\[18\] [http://en.wikipedia.org/wiki/Hard\_disk\_drive][http_en.wikipedia.org_wiki_Hard_disk_drive]  
\[19\] [http://en.wikipedia.org/wiki/Hard\_disk\_drive\_performance\_characteristics][http_en.wikipedia.org_wiki_Hard_disk_drive_performance_characteristics]  
\[20\] [http://centon.com/flash-products/chiptype][http_centon.com_flash-products_chiptype]  
\[21\] [http://www.thessdreview.com/our-reviews/samsung-64gb-mlc-ssd/][http_www.thessdreview.com_our-reviews_samsung-64gb-mlc-ssd]  
\[22\] [http://www.anandtech.com/show/7594/samsung-ssd-840-evo-msata-120gb-250gb-500gb-1tb-review][http_www.anandtech.com_show_7594_samsung-ssd-840-evo-msata-120gb-250gb-500gb-1tb-review]  
\[23\] [http://www.anandtech.com/show/6337/samsung-ssd-840-250gb-review/2][http_www.anandtech.com_show_6337_samsung-ssd-840-250gb-review_2]  
\[24\] [http://www.storagereview.com/ssd\_vs\_hdd][http_www.storagereview.com_ssd_vs_hdd]  
\[25\] [http://www.storagereview.com/wd\_black\_4tb\_desktop\_hard\_drive\_review\_wd4003fzex][http_www.storagereview.com_wd_black_4tb_desktop_hard_drive_review_wd4003fzex]  
\[26\] [http://www.storagereview.com/samsung\_ssd\_840\_pro\_review][http_www.storagereview.com_samsung_ssd_840_pro_review]  
\[27\] [http://www.storagereview.com/micron\_p420m\_enterprise\_pcie\_ssd\_review][http_www.storagereview.com_micron_p420m_enterprise_pcie_ssd_review]  
\[28\] [http://www.storagereview.com/intel\_x25-m\_ssd\_review][http_www.storagereview.com_intel_x25-m_ssd_review]  
\[29\] [http://www.storagereview.com/seagate\_momentus\_xt\_750gb\_review][http_www.storagereview.com_seagate_momentus_xt_750gb_review]  
\[30\] [http://www.storagereview.com/corsair\_vengeance\_ddr3\_ram\_disk\_review][http_www.storagereview.com_corsair_vengeance_ddr3_ram_disk_review]  
\[31\] [http://arstechnica.com/information-technology/2012/06/inside-the-ssd-revolution-how-solid-state-disks-really-work/][http_arstechnica.com_information-technology_2012_06_inside-the-ssd-revolution-how-solid-state-disks-really-work]  
\[32\] [http://www.anandtech.com/show/2738][http_www.anandtech.com_show_2738]  
\[33\] [http://www.anandtech.com/show/2829][http_www.anandtech.com_show_2829]  
\[34\] [http://www.anandtech.com/show/6489][http_www.anandtech.com_show_6489]  
\[35\] [http://lwn.net/Articles/353411/][http_lwn.net_Articles_353411]  
\[36\] [http://us.hardware.info/reviews/4178/10/hardwareinfo-tests-lifespan-of-samsung-ssd-840-250gb-tlc-ssd-updated-with-final-conclusion-final-update-20-6-2013][http_us.hardware.info_reviews_4178_10_hardwareinfo-tests-lifespan-of-samsung-ssd-840-250gb-tlc-ssd-updated-with-final-conclusion-final-update-20-6-2013]  
\[37\] [http://www.anandtech.com/show/6489/playing-with-op][http_www.anandtech.com_show_6489_playing-with-op]  
\[38\] [http://www.ssdperformanceblog.com/2011/06/intel-320-ssd-random-write-performance/][http_www.ssdperformanceblog.com_2011_06_intel-320-ssd-random-write-performance]  
\[39\] [http://en.wikipedia.org/wiki/Native\_Command\_Queuing][http_en.wikipedia.org_wiki_Native_Command_Queuing]  
\[40\] [http://superuser.com/questions/228657/which-linux-filesystem-works-best-with-ssd/][http_superuser.com_questions_228657_which-linux-filesystem-works-best-with-ssd]  
\[41\] [http://blog.superuser.com/2011/05/10/maximizing-the-lifetime-of-your-ssd/][http_blog.superuser.com_2011_05_10_maximizing-the-lifetime-of-your-ssd]  
\[42\] [http://serverfault.com/questions/356534/ssd-erase-block-size-lvm-pv-on-raw-device-alignment][http_serverfault.com_questions_356534_ssd-erase-block-size-lvm-pv-on-raw-device-alignment]  
\[43\] [http://rethinkdb.com/blog/page-alignment-on-ssds/][http_rethinkdb.com_blog_page-alignment-on-ssds]  
\[44\] [http://rethinkdb.com/blog/more-on-alignment-ext2-and-partitioning-on-ssds/][http_rethinkdb.com_blog_more-on-alignment-ext2-and-partitioning-on-ssds]  
\[45\] [http://rickardnobel.se/storage-performance-iops-latency-throughput/][http_rickardnobel.se_storage-performance-iops-latency-throughput]  
\[46\] [http://www.brentozar.com/archive/2013/09/iops-are-a-scam/][http_www.brentozar.com_archive_2013_09_iops-are-a-scam]  
\[47\] [http://www.acunu.com/2/post/2011/08/why-theory-fails-for-ssds.html][http_www.acunu.com_2_post_2011_08_why-theory-fails-for-ssds.html]  
\[48\] [http://security.stackexchange.com/questions/12503/can-wiped-ssd-data-be-recovered][http_security.stackexchange.com_questions_12503_can-wiped-ssd-data-be-recovered]  
\[49\] [http://security.stackexchange.com/questions/5662/is-it-enough-to-only-wipe-a-flash-drive-once][http_security.stackexchange.com_questions_5662_is-it-enough-to-only-wipe-a-flash-drive-once]  
\[50\] [http://searchsolidstatestorage.techtarget.com/feature/The-truth-about-SSD-performance-benchmarks][http_searchsolidstatestorage.techtarget.com_feature_The-truth-about-SSD-performance-benchmarks]  
\[51\][http://www.theregister.co.uk/2012/12/03/macronix\_thermal\_annealing\_extends\_life\_of\_flash\_memory/][http_www.theregister.co.uk_2012_12_03_macronix_thermal_annealing_extends_life_of_flash_memory]  
\[52\] [http://www.eecs.berkeley.edu/~rcs/research/interactive\_latency.html][http_www.eecs.berkeley.edu_rcs_research_interactive_latency.html]  
\[53\] [http://blog.nuclex-games.com/2009/12/aligning-an-ssd-on-linux/][http_blog.nuclex-games.com_2009_12_aligning-an-ssd-on-linux]  
\[54\] [http://www.linux-mag.com/id/8397/][http_www.linux-mag.com_id_8397]  
\[55\] [http://tytso.livejournal.com/2009/02/20/][http_tytso.livejournal.com_2009_02_20]  
\[56\] [https://wiki.debian.org/SSDOptimization][https_wiki.debian.org_SSDOptimization]  
\[57\] [http://wiki.gentoo.org/wiki/SSD][http_wiki.gentoo.org_wiki_SSD]  
\[58\] [https://wiki.archlinux.org/index.php/Solid\_State\_Drives][https_wiki.archlinux.org_index.php_Solid_State_Drives]  
\[59\] [https://www.kernel.org/doc/Documentation/block/cfq-iosched.txt][https_www.kernel.org_doc_Documentation_block_cfq-iosched.txt]  
\[60\] [http://www.danielscottlawrence.com/blog/should\_i\_change\_my\_disk\_scheduler\_to\_use\_NOOP.html][http_www.danielscottlawrence.com_blog_should_i_change_my_disk_scheduler_to_use_NOOP.html]  
\[61\] [http://www.phoronix.com/scan.php?page=article&item=linux\_iosched\_2012][http_www.phoronix.com_scan.php_page_article_item_linux_iosched_2012]  
\[62\] [http://www.velobit.com/storage-performance-blog/bid/126135/Effects-Of-Linux-IO-Scheduler-On-SSD-Performance][http_www.velobit.com_storage-performance-blog_bid_126135_Effects-Of-Linux-IO-Scheduler-On-SSD-Performance]  
\[63\] [http://www.axpad.com/blog/301][http_www.axpad.com_blog_301]  
\[64\] [http://en.wikipedia.org/wiki/List\_of\_solid-state\_drive\_manufacturers][http_en.wikipedia.org_wiki_List_of_solid-state_drive_manufacturers]  
\[65\] [http://en.wikipedia.org/wiki/List\_of\_flash\_memory\_controller\_manufacturers][http_en.wikipedia.org_wiki_List_of_flash_memory_controller_manufacturers]  
\[66\] [http://blog.zorinaq.com/?e=29][http_blog.zorinaq.com_e_29]  
\[67\] [http://www.gamersnexus.net/guides/956-how-ssds-are-made][http_www.gamersnexus.net_guides_956-how-ssds-are-made]  
\[68\] [http://www.gamersnexus.net/guides/1148-how-ram-and-ssds-are-made-smt-lines][http_www.gamersnexus.net_guides_1148-how-ram-and-ssds-are-made-smt-lines]  
\[69\][http://www.tweaktown.com/articles/4655/kingston\_factory\_tour\_making\_of\_an\_ssd\_from\_start\_to\_finish/index.html][http_www.tweaktown.com_articles_4655_kingston_factory_tour_making_of_an_ssd_from_start_to_finish_index.html]  
\[70\] [http://www.youtube.com/watch?v=DvA9koAMXR8][http_www.youtube.com_watch_v_DvA9koAMXR8]  
\[71\] [http://www.youtube.com/watch?v=3s7KG6QwUeQ][http_www.youtube.com_watch_v_3s7KG6QwUeQ]  
\[72\] [Understanding the Robustness of SSDs under Power Fault, Zheng et al., 2013][Understanding the Robustness of SSDs under Power Fault_ Zheng et al._ 2013] — [\[discussion on HN\]][discussion on HN]  
\[73\] [http://lkcl.net/reports/ssd\_analysis.html][http_lkcl.net_reports_ssd_analysis.html] — [\[discussion on HN\]][discussion on HN 1]

文章来源：http://blog.jobbole.com/?s=%E4%B8%BASSD%E7%BC%96%E7%A8%8B

# 第二部分：（英文原文） #

来源：http://codecapsule.com/2014/02/12/coding-for-ssds-part-2-architecture-of-an-ssd-and-benchmarking/

This is Part 2 over 6 of “Coding for SSDs”, covering Sections 1 and 2. For other parts and sections, you can refer to the [Table to Contents][Emmanuel Goossaert _CodeCapsule.com]. This is a series of articles that I wrote to share what I learned while documenting myself on SSDs, and on how to make code perform well on SSDs. If you’re in a rush, you can also go directly to [Part 6][Link 5], which is summarizing the content from all the other parts.

In this part, I am explaining the basics of NAND-flash memory, cell types, and basic SSD internal architecture. I am also covering SSD benchmarking and how to interpret those benchmarks.

![ssd-presentation-02][]

To receive a notification email every time a new article is posted on Code Capsule, you can subscribe to the newsletter by filling up the form at the top right corner of the blog.  
As usual, comments are open at the bottom of this post, and I am always happy to welcome questions, corrections and contributions!

## 1. Structure of an SSD ##

### 1.1 NAND-flash memory cells ###

A solid-state drives (SSD) is a flash-memory based data storage device. Bits are stored into cells, which are made of floating-gate transistors. SSDs are made entirely of electronic components, there are no moving or mechanical parts like in hard drives.

Voltages are applied to the floating-gate transistors, which is how bits are being read, written, and erased. Two solutions exist for wiring transistors: the NOR flash memory, and the NAND flash memory. I will not go into more details regarding the difference between NOR and NAND flash memory. This article only covers NAND flash memory, which is the solution chosen by the majority of the manufacturers. For more information on the difference between NOR and NAND, you can refer to this article by Lee Hutchinson [\[31\]][31 1].

An important property of NAND-flash modules is that their cells are wearing off, and therefore have a limited lifespan. Indeed, the transistors forming the cells store bits by holding electrons. At each P/E cycle (i.e. Program/Erase, “Program” here means write), electrons might get trapped in the transistor by mistake, and after some time, too many electrons will have been trapped and the cells would become unusable.

#### Limited lifespan ####

Each cell has a maximum number of P/E cycles (Program/Erase), after which the cell is considered defective. NAND-flash memory wears off and has a limited lifespan. The different types of NAND-flash memory have different lifespans [\[31\]][31 1].

Recent research has shown that by applying very high temperatures to NAND chips, trapped electrons can be cleared out [\[14, 51\]][31 1]. The lifespan of SSDs could be tremendously increased, though this is still research and there is no certainty that this will one day reach the consumer market.

The types of cells currently present in the industry are:

*  Single level cell (SLC), in which transistors can store only 1 bit but have a long lifespan
 *  Multiple level cell (MLC), in which transistors can store 2 bits, at the cost of a higher latency and reduced lifespan compared to SLC
 *  Triple-level cell (TLC), in which transistors can store 3 bits, but at an even higher latency and reduced lifespan

#### Memory cell types ####

A solid-state drives (SSD) is a flash-memory based data storage device. Bits are stored into cells, which exist in three types: 1 bit per cell (single level cell, SLC), 2 bits per cell (multiple level cell, MLC), and 3 bits per cell (triple-level cell, TLC).

Table 1 below shows detailed information for each NAND-flash cell type. For the sake of comparison, I have also added the average latencies of hard drives, main memory (RAM), and L1/L2 caches.

Table 1: Characteristics and latencies of NAND-flash memory types compared to other memory components

Having more bits for the same amount of transistors reduces the manufacturing costs. SLC-based SSDs are known to be more reliable and have a longer life expectancy than MLC-based SSDs, but at a higher manufacturing cost. Therefore, most general public SSDs are MLC- or TLC-based, and only professional SSDs are SLC-based. Choosing the right memory type depends on the workload the drive will be used for, and how often the data is likely to be updated. For high-update workloads, SLC is the best choice, whereas for high-read and low-write workloads (ex: video storage and streaming), then TLC will be perfectly fine. Moreover, benchmarks of TLC drives under a workload of realistic usage show that the lifespan of TLC-based SSDs is not a concern in practice [\[36\]][31 1].

#### NAND-flash pages and blocks ####

Cells are grouped into a grid, called a **block**, and blocks are grouped into planes. The smallest unit through which a block can be read or written is a **page**. Pages cannot be erased individually, only whole blocks can be erased. The size of a NAND-flash page size can vary, and most drive have pages of size 2 KB, 4 KB, 8 KB or 16 KB. Most SSDs have blocks of 128 or 256 pages, which means that the size of a block can vary between 256 KB and 4 MB. For example, the Samsung SSD 840 EVO has blocks of size 2048 KB, and each block contains 256 pages of 8 KB each. The way pages and blocks can be accessed is covered in details in Section 3.1.

### 1.2 Organization of an SSD ###

Figure 1 below is representing an SSD drive and its main components. I have simply reproduced the basic schematic already presented in various papers [\[2, 3, 6\]][31 1].

![ssd-architecture][]

Figure 1: Architecture of a solid-state drive

Commands come from the user through the host interface. At the moment I am writing this article, the two most common interfaces for newly released SSDs are Serial ATA (SATA), PCI Express (PCIe). The processor in the SSD controller takes the commands and pass them to the flash controller. SSDs also have embedded RAM memory, generally for caching purposes and to store mapping information. Section 4 covers mapping policies in more details. The packages of NAND flash memory are organized in gangs, over multiple channels, which is covered in Section 6.

Figure 2 and 3 below, reproduced from StorageReview.com [\[26, 27\]][31 1], show what SSDs look like in real life. Figure 2 shows the 512 GB version of the Samsung 840 Pro SSD, released in August 2013. As it can be seen on the circuit board, the main components are:

*  1 SATA 3.0 interface
 *  1 SSD controller (Samsung MDX S4LN021X01-8030)
 *  1 RAM module (256 MB DDR2 Samsung K4P4G324EB-FGC2)
 *  8 MLC NAND-flash modules, each offering 64 GB of storage (Samsung K9PHGY8U7A-CCK0)

![samsungssd840pro-01][]  
![samsungssd840pro-02][]

Figure 2: Samsung SSD 840 Pro (512 GB) — *Pictures courtesy of StorageReview.com [\[26\]][31 1]*

Figure 3 is a Micron P420m Enterprise PCIe, released late 2013. The main components are:

*  8 lanes of a PCI Express 2.0 interface
 *  1 SSD controller
 *  1 RAM module (DRAM DDR3)
 *  64 MLC NAND-flash modules over 32 channels, each module offering 32 GB of storage (Micron 31C12NQ314 25nm)

The total memory is 2048 GB, but only 1.4 TB are available after over-provisioning.

![micron-p420m-01][]  
![micron-p420m-02][]

Figure 3: Micron P420m Enterprise PCIe (1.4 TB) — *Pictures courtesy of StorageReview.com [\[27\]][31 1]*

### 1.3 Manufacturing process ###

Many SSD manufacturers use surface-mount technology (SMT) to produce SSDs, a production method in which electronic components are placed directly on top of printed circuit boards (PCBs). SMT lines are composed of a chain of machines, each machine being plugged into the next and having a specific task to perform in the process, such as placing components or melting the solder. Multiple quality checks are also performed throughout the entire process. Photos and videos of SMT lines can be seen in two articles by Steve Burke [\[67, 68\]][31 1], in which he visited the production facilities of Kingston Technologies in Fountain Valley, California, and in an article by Cameron Wilmot about the Kingston installations in Taiwan [\[69\]][31 1].

Other interesting resources are two videos, the first one about the Crucial SSDs by Micron [\[70\]][31 1] and the second one about Kingston [\[71\]][31 1]. In the latter, which is part of Steve Burke’s articles and that I also have embedded below, Mark Tekunoff from Kingston is giving a tour of one of their SMT lines. Interesting detail, everyone in the video is wearing a cute antistatic pyjama and seems to be having a lot of fun!

width="640" height="360" src="http://www.youtube.com/embed/3s7KG6QwUeQ" frameborder="0" allowfullscreen="">

## 2. Benchmarking and performance metrics ##

### 2.1 Basic benchmarks ###

Table 2 below shows the throughput for sequential and random workloads on different solid-state drives. For the sake of comparison, I have included SSDs released in 2008 and 2013, along with one hard drive, and one RAM memory chip.

<table style="border-collapse: collapse; border-spacing: 0px; border-color: rgb(170, 170, 170); width: 800px; color: rgb(0, 0, 0); font-family: Avenir, 'Segoe UI', 'Lucida Grande', Lucida, Verdana, sans-serif; font-size: 21.06px; line-height: 31.59px;"> 
 <tbody> 
 <tr> 
 <th style="font-family: Arial, sans-serif; font-size: 21.06px; font-weight: normal; padding: 10px 5px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(255, 255, 255); background-color: rgb(58, 135, 173);">&nbsp;</th> 
 <th style="font-family: Arial, sans-serif; font-size: 21.06px; font-weight: normal; padding: 10px 5px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(255, 255, 255); background-color: rgb(58, 135, 173);">Samsung 64 GB</th> 
 <th style="font-family: Arial, sans-serif; font-size: 21.06px; font-weight: normal; padding: 10px 5px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(255, 255, 255); background-color: rgb(58, 135, 173);">Intel X25-M</th> 
 <th style="font-family: Arial, sans-serif; font-size: 21.06px; font-weight: normal; padding: 10px 5px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(255, 255, 255); background-color: rgb(58, 135, 173);">Samsung 840 EVO</th> 
 <th style="font-family: Arial, sans-serif; font-size: 21.06px; font-weight: normal; padding: 10px 5px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(255, 255, 255); background-color: rgb(58, 135, 173);">Micron P420m</th> 
 <th style="font-family: Arial, sans-serif; font-size: 21.06px; font-weight: normal; padding: 10px 5px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(255, 255, 255); background-color: rgb(58, 135, 173);">HDD</th> 
 <th style="font-family: Arial, sans-serif; font-size: 21.06px; font-weight: normal; padding: 10px 5px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(255, 255, 255); background-color: rgb(58, 135, 173);">RAM</th> 
 </tr> 
 <tr> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51); background-color: rgb(240, 247, 253);">Brand/Model</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51); background-color: rgb(240, 247, 253);">Samsung(MCCDE64G5MPP-OVA)</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51); background-color: rgb(240, 247, 253);">Intel X25-M(SSDSA2MH080G1GC)</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51); background-color: rgb(240, 247, 253);">Samsung&nbsp;(SSD 840 EVO mSATA)</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51); background-color: rgb(240, 247, 253);">Micron P420m</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51); background-color: rgb(240, 247, 253);">Western Digital Black 7200 rpm</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51); background-color: rgb(240, 247, 253);">Corsair Vengeance DDR3</td> 
 </tr> 
 <tr> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51);">Memory cell type</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51);">MLC</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51);">MLC</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51);">TLC</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51);">MLC</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51);">*</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51);">*</td> 
 </tr> 
 <tr> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51); background-color: rgb(240, 247, 253);">Release year</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51); background-color: rgb(240, 247, 253);">2008</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51); background-color: rgb(240, 247, 253);">2008</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51); background-color: rgb(240, 247, 253);">2013</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51); background-color: rgb(240, 247, 253);">2013</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51); background-color: rgb(240, 247, 253);">2013</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51); background-color: rgb(240, 247, 253);">2012</td> 
 </tr> 
 <tr> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51);">Interface</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51);">SATA 2.0</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51);">SATA 2.0</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51);">SATA 3.0</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51);">PCIe 2.0</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51);">SATA 3.0</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51);">*</td> 
 </tr> 
 <tr> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51); background-color: rgb(240, 247, 253);">Total capacity</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51); background-color: rgb(240, 247, 253);">64 GB</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51); background-color: rgb(240, 247, 253);">80 GB</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51); background-color: rgb(240, 247, 253);">1 TB</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51); background-color: rgb(240, 247, 253);">1.4 TB</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51); background-color: rgb(240, 247, 253);">4 TB</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51); background-color: rgb(240, 247, 253);">4 x 4 GB</td> 
 </tr> 
 <tr> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51);">Pages per block</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51);">128</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51);">128</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51);">256</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51);">512</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51);">*</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51);">*</td> 
 </tr> 
 <tr> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51); background-color: rgb(240, 247, 253);">Page size</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51); background-color: rgb(240, 247, 253);">4 KB</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51); background-color: rgb(240, 247, 253);">4 KB</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51); background-color: rgb(240, 247, 253);">8 KB</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51); background-color: rgb(240, 247, 253);">16 KB</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51); background-color: rgb(240, 247, 253);">*</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51); background-color: rgb(240, 247, 253);">*</td> 
 </tr> 
 <tr> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51);">Block size</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51);">512 KB</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51);">512 KB</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51);">2048 KB</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51);">8196 KB</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51);">*</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51);">*</td> 
 </tr> 
 <tr> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51); background-color: rgb(240, 247, 253);">Sequential reads (MB/s)</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51); background-color: rgb(240, 247, 253);">100</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51); background-color: rgb(240, 247, 253);">254</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51); background-color: rgb(240, 247, 253);">540</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51); background-color: rgb(240, 247, 253);">3300</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51); background-color: rgb(240, 247, 253);">185</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51); background-color: rgb(240, 247, 253);">7233</td> 
 </tr> 
 <tr> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51);">Sequential writes (MB/s)</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51);">92</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51);">78</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51);">520</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51);">630</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51);">185</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51);">5872</td> 
 </tr> 
 <tr> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51); background-color: rgb(240, 247, 253);">4KB random reads (MB/s)</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51); background-color: rgb(240, 247, 253);">17</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51); background-color: rgb(240, 247, 253);">23.6</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51); background-color: rgb(240, 247, 253);">383</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51); background-color: rgb(240, 247, 253);">2292</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51); background-color: rgb(240, 247, 253);">0.54</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51); background-color: rgb(240, 247, 253);">5319 **</td> 
 </tr> 
 <tr> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51);">4KB random writes (MB/s)</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51);">5.5</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51);">11.2</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51);">352</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51);">390</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51);">0.85</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51);">5729 **</td> 
 </tr> 
 <tr> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51); background-color: rgb(240, 247, 253);">4KB Random reads (KIOPS)</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51); background-color: rgb(240, 247, 253);">4</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51); background-color: rgb(240, 247, 253);">6</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51); background-color: rgb(240, 247, 253);">98</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51); background-color: rgb(240, 247, 253);">587</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51); background-color: rgb(240, 247, 253);">0.14</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51); background-color: rgb(240, 247, 253);">105</td> 
 </tr> 
 <tr> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51);">4KB Random writes (KIOPS)</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51);">1.5</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51);">2.8</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51);">90</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51);">100</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51);">0.22</td> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51);">102</td> 
 </tr> 
 <tr> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51); background-color: rgb(247, 247, 247);">Notes</td> 
 <td colspan="6" style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51); background-color: rgb(247, 247, 247);">* metric is not applicable for that storage solution ** measured with 2 MB chunks, not 4 KB</td> 
 </tr> 
 <tr> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51); background-color: rgb(247, 247, 247);">Metrics</td> 
 <td colspan="6" style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51); background-color: rgb(247, 247, 247);">MB/s: Megabytes per Second KIOPS: Kilo IOPS, i.e 1000 Input/Output Operations Per Second</td> 
 </tr> 
 <tr> 
 <td style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51); background-color: rgb(247, 247, 247);">Sources</td> 
 <td colspan="6" style="font-family: Arial, sans-serif; font-size: 14px; padding: 10px 8px; border-style: solid; border-width: 1px 0px; border-color: rgb(170, 170, 170); color: rgb(51, 51, 51); background-color: rgb(247, 247, 247);">Samsung 64 GB&nbsp;<a href="http://codecapsule.com/2014/02/12/coding-for-ssds-part-2-architecture-of-an-ssd-and-benchmarking/#ref" style="color: rgb(38, 83, 139);" rel="nofollow">[21]</a> Intel X25-M&nbsp;<a href="http://codecapsule.com/2014/02/12/coding-for-ssds-part-2-architecture-of-an-ssd-and-benchmarking/#ref" style="color: rgb(38, 83, 139);" rel="nofollow">[2, 28]</a> Samsung SSD 840 EVO&nbsp;<a href="http://codecapsule.com/2014/02/12/coding-for-ssds-part-2-architecture-of-an-ssd-and-benchmarking/#ref" style="color: rgb(38, 83, 139);" rel="nofollow">[22]</a> Micron P420M&nbsp;<a href="http://codecapsule.com/2014/02/12/coding-for-ssds-part-2-architecture-of-an-ssd-and-benchmarking/#ref" style="color: rgb(38, 83, 139);" rel="nofollow">[27]</a> Western Digital Black 4 TB&nbsp;<a href="http://codecapsule.com/2014/02/12/coding-for-ssds-part-2-architecture-of-an-ssd-and-benchmarking/#ref" style="color: rgb(38, 83, 139);" rel="nofollow">[25]</a> Corsair Vengeance DDR3 RAM&nbsp;<a href="http://codecapsule.com/2014/02/12/coding-for-ssds-part-2-architecture-of-an-ssd-and-benchmarking/#ref" style="color: rgb(38, 83, 139);" rel="nofollow">[30]</a></td> 
 </tr> 
 </tbody> 
</table>

Table 2: Characteristics and throughput of solid-state drives compared to other storage solutions

An important factor for performance is the host interface. The most common interfaces for newly released SSDs are SATA 3.0, PCI Express 3.0. On a SATA 3.0 interface, data can be transferred up to 6 Gbit/s, which in practice gives around 550 MB/s, and on a PCIe 3.0 interface, data can be transferred up to 8 GT/s per lane, which in practice is roughly 1 GB/s (GT/s stands for Gigatransfers per second). SSDs on the PCIe 3.0 interface are more than a single lane. With four lanes, PCIe 3.0 can offer a maximum bandwidth of 4 GB/s, which is eight times faster than SATA 3.0. Some enterprise SSDs also offer a Serial Attached SCSI interface (SAS) which in its latest version can offer up to 12 GBit/s, although at the moment SAS is only a tiny fraction of the market.

Most recent SSDs are fast enough internally to easily reach the 550 MB/s limitation of SATA 3.0, therefore the interface is the bottleneck for them. The SSDs using PCI Express 3.0 or SAS offer tremendous performance increases [\[15\]][31 1].

#### PCI Express and SAS are faster than SATA ####

The two main host interfaces offered by manufacturers are SATA 3.0 (550 MB/s) and PCI Express 3.0 (1 GB/s per lane, using multiple lanes). Serial Attached SCSI (SAS) is also available for enterprise SSDs. In their latest versions, PCI Express and SAS are faster than SATA, but they are also more expensive.

### 2.2 Pre-conditioning ###

> If you torture the data long enough, it will confess.  
> — Ronald Coase

The data sheets provided by SSD manufacturers are filled with amazing performance values. And indeed, by banging whatever random operations for long enough, manufacturers seem to always find a way to show shinny numbers in their marketing flyers. Whether or not those numbers really mean anything and allow to predict the performance of a production system is a different problem.

In his articles about common flaws in SSD benchmarking [\[66\]][31 1], Marc Bevand mentioned that for instance it is common for the IOPS of random write workloads to be reported without any mention of the span of the LBA, and that many IOPS are also reported for queue depth of 1 instead of the maximum value for the drive being tested. There are also many cases of bugs and misuses of the benchmarking tools.

Correctly assessing the performance of SSDs is not an easy task. Many articles from hardware reviewing blogs run ten minutes of random writes on a drive and claim that the drive is ready to be tested, and that the results can be trusted. However, the performance of SSDs only drops under a sustained workload of random writes, which depending on the total size of the SSD can take just 30 minutes or up to three hours. This is why the more serious benchmarks start by applying such a sustained workload of random writes, also called “*pre-conditioning*” [\[50\]][31 1]. Figure 7 below, reproduced from an article on StorageReview.com [\[26\]][31 1], shows the effect of pre-conditioning on multiple SSDs. A clear drop in performance can be observed after around 30 minutes, where the throughput decreases and the latency increases for all drives. It then takes another four hours for the performance to slowly decay to a constant minimum.

![writes-preconditioning][]

Figure 7: Effect of pre-conditioning on multiple SSD models — *Pictures courtesy of StorageReview.com[\[26\]][31 1]*

What is happening in Figure 7 essentially is that, as explained in Section 5.2, the amount of random writes is so large and applied in such a sustained way that the garbage collection process is unable to keep up in background. The garbage collection must erase blocks as write commands arrive, therefore competing with the foreground operations from the host. People using pre-conditioning claim that the benchmarks it produces accurately represent how a drive will behave in its worst possible state. Whether or not this is a good model for how a drive will behave under all workloads is arguable.

In order to compare various models coming from different manufacturers, a common ground must be found, and the worst possible state is a valid one. But picking the drive that performs best under the worst possible workload does not always guarantee that it will perform best under the workload of a production environment. Indeed, in most production environments, an SSD drive will serve one and only one system. That system has a specific workload due to its internal characteristics, and therefore a better and more accurate way to compare different drives would be to run the same replay of this workload on those drives, and then compare their respective performance. This is why, even though a pre-conditioning using a sustained workload of random writes allows for a fair comparison of different SSDs, one has to be careful and should, whenever possible, run in-house benchmarks based on the target workload. Benchmarking in-house also allows not to over-allocate resources, by avoiding using the “best” SSD model when a cheaper one would be enough and save a lot of money.

#### Benchmarking is hard ####

Testers are humans, therefore not all benchmarks are exempt of errors. Be careful when reading the benchmarks from manufacturers or third parties, and use multiple sources before trusting any numbers. Whenever possible, run your own in-house benchmarking using the specific workload of your system, along with the specific SSD model that you want to use. Finally, make sure you look at the performance metrics that matter most for the system at hand.

### 2.3 Workloads and metrics ###

Performance benchmarks all share the same varying parameters and provide results using the same metrics. In this section, I wish to give some insights as to how to interpret those parameters and metrics.

The parameters used are generally the following:

*  The type of workload: can be a specific benchmark based on data collected from users, or just only sequential or random accesses of the same type (ex: only random writes)
 *  The percentages of reads and writes performed concurrently (ex: 30% reads and 70% writes)
 *  The queue length: this is the number of concurrent execution threads running commands on a drive
 *  The size of the data chunks being accessed (4 KB, 8 KB, etc.)

Benchmark results are presented using different metrics. The most common are:

*  Throughput: The speed of transfer, generally in KB/s or MB/s, respectively kilobytes per second, and megabytes per second. This is the metric chosen for sequential benchmarks.
 *  IOPS: the number of Input/Output Operations Per Second, each operations being of the same data chunk size (generally 4 KB/s). This is the metrics chosen for the random benchmarks.
 *  [\[17\]][31 1]
 *  Latency: the response time of a device after a command is emitted, generally in μs or ms, respectively microseconds or milliseconds.

While the throughput is easy to understand and relate to, the IOPS is more difficult to grasp. For example, if a disk shows a performance for random writes at 1000 IOPS for 4 KB chunks, this means that the throughput is of 1000 x 4096 = 4 MB/s. Consequently, a high IOPS will translate into a high throughput only if the size of the chunks is the largest possible. A high IOPS at a low average chuck size will translate into a low throughput.

To illustrate this point, let’s imagine that we have a logging system performing tiny updates over thousands of different files per minute, giving a performance of 10k IOPS. Because the updates are spread over so many different files, the throughput could be close to something like 20 MB/s, whereas writing sequentially to only one file with the same system could lead to an increased throughput of 200 MB/s, which is a tenfold improvement. I am making up those numbers for the sake of this example, although they are close to production systems I have encountered.

Another concept to grasp is that a high throughput does not necessarily means a fast system. Indeed, if the latency is high, no matter how good is the throughput, the overall system will be slow. Let’s take the example of a hypothetical single-threaded process that requires connections to 25 databases, each connection having a latency of 20 ms. Because the connection latencies are cumulative, obtaining the 25 connections will require 25 x 20 ms = 500 ms. Therefore, even if the machines running the database queries have fast network cards, let’s say 5 GBits/s of bandwidth, the script will still be slow due to the latency.

The takeaway from this section is that it is important to keep an eye on all the metrics, as they will show different aspects of the system and will allow to identify the bottlenecks when they come up. When looking at the benchmarks of SSDs and deciding which model to pick, keeping in mind which metric is the most critical to the system in which those SSDs will used is generally a good rule of thumb. Then of course, nothing will replace proper in-house benchmarking as explained in Section 2.2.

An interesting follow-up on the topic is the article “*IOPS are a scam*” by Jeremiah Peschka [\[46\]][31 1].

## What’s next ##

Part 3 is available [here][]. You can also go to the [Table of Content][Emmanuel Goossaert _CodeCapsule.com] for this series of articles, and if you’re in a rush, you can also directly go to Part 6, which is summarizing the content from all the other parts.

## Translations ##

This article was [translated to Simplified Chinese][] by Xiong Duo.

## References ##

\[1\] [Understanding Intrinsic Characteristics and System Implications of Flash Memory based Solid State Drives, Chen et al., 2009][Understanding Intrinsic Characteristics and System Implications of Flash Memory based Solid State Drives_ Chen et al._ 2009]  
\[2\] [Parameter-Aware I/O Management for Solid State Disks (SSDs), Kim et al., 2012][Parameter-Aware I_O Management for Solid State Disks _SSDs_ Kim et al._ 2012]  
\[3\] [Essential roles of exploiting internal parallelism of flash memory based solid state drives in high-speed data processing, Chen et al, 2011][Essential roles of exploiting internal parallelism of flash memory based solid state drives in high-speed data processing_ Chen et al_ 2011]  
\[4\] [Exploring and Exploiting the Multilevel Parallelism Inside SSDs for Improved Performance and Endurance, Hu et al., 2013][Exploring and Exploiting the Multilevel Parallelism Inside SSDs for Improved Performance and Endurance_ Hu et al._ 2013]  
\[5\] [Design Tradeoffs for SSD Performance, Agrawal et al., 2008][Design Tradeoffs for SSD Performance_ Agrawal et al._ 2008]  
\[6\] [Design Patterns for Tunable and Efficient SSD-based Indexes, Anand et al., 2012][Design Patterns for Tunable and Efficient SSD-based Indexes_ Anand et al._ 2012]  
\[7\] [BPLRU: A Buffer Management Scheme for Improving Random Writes in Flash Storage, Kim et al., 2008][BPLRU_ A Buffer Management Scheme for Improving Random Writes in Flash Storage_ Kim et al._ 2008]  
\[8\] [SFS: Random Write Considered Harmful in Solid State Drives, Min et al., 2012][SFS_ Random Write Considered Harmful in Solid State Drives_ Min et al._ 2012]  
\[9\] [A Survey of Flash Translation Layer, Chung et al., 2009][A Survey of Flash Translation Layer_ Chung et al._ 2009]  
\[10\] [A Reconfigurable FTL (Flash Translation Layer) Architecture for NAND Flash-Based Applications, Park et al., 2008][A Reconfigurable FTL _Flash Translation Layer_ Architecture for NAND Flash-Based Applications_ Park et al._ 2008]  
\[11\] [Reliably Erasing Data From Flash-Based Solid State Drives, Wei et al., 2011][Reliably Erasing Data From Flash-Based Solid State Drives_ Wei et al._ 2011]  
\[12\] [http://en.wikipedia.org/wiki/Solid-state\_drive][http_en.wikipedia.org_wiki_Solid-state_drive]  
\[13\] [http://en.wikipedia.org/wiki/Write\_amplification][http_en.wikipedia.org_wiki_Write_amplification]  
\[14\] [http://en.wikipedia.org/wiki/Flash\_memory][http_en.wikipedia.org_wiki_Flash_memory]  
\[15\] [http://en.wikipedia.org/wiki/Serial\_ATA][http_en.wikipedia.org_wiki_Serial_ATA]  
\[16\] [http://en.wikipedia.org/wiki/Trim\_(computing)][http_en.wikipedia.org_wiki_Trim_computing]  
\[17\] [http://en.wikipedia.org/wiki/IOPS][http_en.wikipedia.org_wiki_IOPS]  
\[18\] [http://en.wikipedia.org/wiki/Hard\_disk\_drive][http_en.wikipedia.org_wiki_Hard_disk_drive]  
\[19\] [http://en.wikipedia.org/wiki/Hard\_disk\_drive\_performance\_characteristics][http_en.wikipedia.org_wiki_Hard_disk_drive_performance_characteristics]  
\[20\] [http://centon.com/flash-products/chiptype][http_centon.com_flash-products_chiptype]  
\[21\] [http://www.thessdreview.com/our-reviews/samsung-64gb-mlc-ssd/][http_www.thessdreview.com_our-reviews_samsung-64gb-mlc-ssd]  
\[22\] [http://www.anandtech.com/show/7594/samsung-ssd-840-evo-msata-120gb-250gb-500gb-1tb-review][http_www.anandtech.com_show_7594_samsung-ssd-840-evo-msata-120gb-250gb-500gb-1tb-review]  
\[23\] [http://www.anandtech.com/show/6337/samsung-ssd-840-250gb-review/2][http_www.anandtech.com_show_6337_samsung-ssd-840-250gb-review_2]  
\[24\] [http://www.storagereview.com/ssd\_vs\_hdd][http_www.storagereview.com_ssd_vs_hdd]  
\[25\] [http://www.storagereview.com/wd\_black\_4tb\_desktop\_hard\_drive\_review\_wd4003fzex][http_www.storagereview.com_wd_black_4tb_desktop_hard_drive_review_wd4003fzex]  
\[26\] [http://www.storagereview.com/samsung\_ssd\_840\_pro\_review][http_www.storagereview.com_samsung_ssd_840_pro_review]  
\[27\] [http://www.storagereview.com/micron\_p420m\_enterprise\_pcie\_ssd\_review][http_www.storagereview.com_micron_p420m_enterprise_pcie_ssd_review]  
\[28\] [http://www.storagereview.com/intel\_x25-m\_ssd\_review][http_www.storagereview.com_intel_x25-m_ssd_review]  
\[29\] [http://www.storagereview.com/seagate\_momentus\_xt\_750gb\_review][http_www.storagereview.com_seagate_momentus_xt_750gb_review]  
\[30\] [http://www.storagereview.com/corsair\_vengeance\_ddr3\_ram\_disk\_review][http_www.storagereview.com_corsair_vengeance_ddr3_ram_disk_review]  
\[31\] [http://arstechnica.com/information-technology/2012/06/inside-the-ssd-revolution-how-solid-state-disks-really-work/][http_arstechnica.com_information-technology_2012_06_inside-the-ssd-revolution-how-solid-state-disks-really-work]  
\[32\] [http://www.anandtech.com/show/2738][http_www.anandtech.com_show_2738]  
\[33\] [http://www.anandtech.com/show/2829][http_www.anandtech.com_show_2829]  
\[34\] [http://www.anandtech.com/show/6489][http_www.anandtech.com_show_6489]  
\[35\] [http://lwn.net/Articles/353411/][http_lwn.net_Articles_353411]  
\[36\] [http://us.hardware.info/reviews/4178/10/hardwareinfo-tests-lifespan-of-samsung-ssd-840-250gb-tlc-ssd-updated-with-final-conclusion-final-update-20-6-2013][http_us.hardware.info_reviews_4178_10_hardwareinfo-tests-lifespan-of-samsung-ssd-840-250gb-tlc-ssd-updated-with-final-conclusion-final-update-20-6-2013]  
\[37\] [http://www.anandtech.com/show/6489/playing-with-op][http_www.anandtech.com_show_6489_playing-with-op]  
\[38\] [http://www.ssdperformanceblog.com/2011/06/intel-320-ssd-random-write-performance/][http_www.ssdperformanceblog.com_2011_06_intel-320-ssd-random-write-performance]  
\[39\] [http://en.wikipedia.org/wiki/Native\_Command\_Queuing][http_en.wikipedia.org_wiki_Native_Command_Queuing]  
\[40\] [http://superuser.com/questions/228657/which-linux-filesystem-works-best-with-ssd/][http_superuser.com_questions_228657_which-linux-filesystem-works-best-with-ssd]  
\[41\] [http://blog.superuser.com/2011/05/10/maximizing-the-lifetime-of-your-ssd/][http_blog.superuser.com_2011_05_10_maximizing-the-lifetime-of-your-ssd]  
\[42\] [http://serverfault.com/questions/356534/ssd-erase-block-size-lvm-pv-on-raw-device-alignment][http_serverfault.com_questions_356534_ssd-erase-block-size-lvm-pv-on-raw-device-alignment]  
\[43\] [http://rethinkdb.com/blog/page-alignment-on-ssds/][http_rethinkdb.com_blog_page-alignment-on-ssds]  
\[44\] [http://rethinkdb.com/blog/more-on-alignment-ext2-and-partitioning-on-ssds/][http_rethinkdb.com_blog_more-on-alignment-ext2-and-partitioning-on-ssds]  
\[45\] [http://rickardnobel.se/storage-performance-iops-latency-throughput/][http_rickardnobel.se_storage-performance-iops-latency-throughput]  
\[46\] [http://www.brentozar.com/archive/2013/09/iops-are-a-scam/][http_www.brentozar.com_archive_2013_09_iops-are-a-scam]  
\[47\] [http://www.acunu.com/2/post/2011/08/why-theory-fails-for-ssds.html][http_www.acunu.com_2_post_2011_08_why-theory-fails-for-ssds.html]  
\[48\] [http://security.stackexchange.com/questions/12503/can-wiped-ssd-data-be-recovered][http_security.stackexchange.com_questions_12503_can-wiped-ssd-data-be-recovered]  
\[49\] [http://security.stackexchange.com/questions/5662/is-it-enough-to-only-wipe-a-flash-drive-once][http_security.stackexchange.com_questions_5662_is-it-enough-to-only-wipe-a-flash-drive-once]  
\[50\] [http://searchsolidstatestorage.techtarget.com/feature/The-truth-about-SSD-performance-benchmarks][http_searchsolidstatestorage.techtarget.com_feature_The-truth-about-SSD-performance-benchmarks]  
\[51\][http://www.theregister.co.uk/2012/12/03/macronix\_thermal\_annealing\_extends\_life\_of\_flash\_memory/][http_www.theregister.co.uk_2012_12_03_macronix_thermal_annealing_extends_life_of_flash_memory]  
\[52\] [http://www.eecs.berkeley.edu/~rcs/research/interactive\_latency.html][http_www.eecs.berkeley.edu_rcs_research_interactive_latency.html]  
\[53\] [http://blog.nuclex-games.com/2009/12/aligning-an-ssd-on-linux/][http_blog.nuclex-games.com_2009_12_aligning-an-ssd-on-linux]  
\[54\] [http://www.linux-mag.com/id/8397/][http_www.linux-mag.com_id_8397]  
\[55\] [http://tytso.livejournal.com/2009/02/20/][http_tytso.livejournal.com_2009_02_20]  
\[56\] [https://wiki.debian.org/SSDOptimization][https_wiki.debian.org_SSDOptimization]  
\[57\] [http://wiki.gentoo.org/wiki/SSD][http_wiki.gentoo.org_wiki_SSD]  
\[58\] [https://wiki.archlinux.org/index.php/Solid\_State\_Drives][https_wiki.archlinux.org_index.php_Solid_State_Drives]  
\[59\] [https://www.kernel.org/doc/Documentation/block/cfq-iosched.txt][https_www.kernel.org_doc_Documentation_block_cfq-iosched.txt]  
\[60\] [http://www.danielscottlawrence.com/blog/should\_i\_change\_my\_disk\_scheduler\_to\_use\_NOOP.html][http_www.danielscottlawrence.com_blog_should_i_change_my_disk_scheduler_to_use_NOOP.html]  
\[61\] [http://www.phoronix.com/scan.php?page=article&item=linux\_iosched\_2012][http_www.phoronix.com_scan.php_page_article_item_linux_iosched_2012]  
\[62\] [http://www.velobit.com/storage-performance-blog/bid/126135/Effects-Of-Linux-IO-Scheduler-On-SSD-Performance][http_www.velobit.com_storage-performance-blog_bid_126135_Effects-Of-Linux-IO-Scheduler-On-SSD-Performance]  
\[63\] [http://www.axpad.com/blog/301][http_www.axpad.com_blog_301]  
\[64\] [http://en.wikipedia.org/wiki/List\_of\_solid-state\_drive\_manufacturers][http_en.wikipedia.org_wiki_List_of_solid-state_drive_manufacturers]  
\[65\] [http://en.wikipedia.org/wiki/List\_of\_flash\_memory\_controller\_manufacturers][http_en.wikipedia.org_wiki_List_of_flash_memory_controller_manufacturers]  
\[66\] [http://blog.zorinaq.com/?e=29][http_blog.zorinaq.com_e_29]  
\[67\] [http://www.gamersnexus.net/guides/956-how-ssds-are-made][http_www.gamersnexus.net_guides_956-how-ssds-are-made]  
\[68\] [http://www.gamersnexus.net/guides/1148-how-ram-and-ssds-are-made-smt-lines][http_www.gamersnexus.net_guides_1148-how-ram-and-ssds-are-made-smt-lines]  
\[69\][http://www.tweaktown.com/articles/4655/kingston\_factory\_tour\_making\_of\_an\_ssd\_from\_start\_to\_finish/index.html][http_www.tweaktown.com_articles_4655_kingston_factory_tour_making_of_an_ssd_from_start_to_finish_index.html]  
\[70\] [http://www.youtube.com/watch?v=DvA9koAMXR8][http_www.youtube.com_watch_v_DvA9koAMXR8]  
\[71\] [http://www.youtube.com/watch?v=3s7KG6QwUeQ][http_www.youtube.com_watch_v_3s7KG6QwUeQ]  
\[72\] [Understanding the Robustness of SSDs under Power Fault, Zheng et al., 2013][Understanding the Robustness of SSDs under Power Fault_ Zheng et al._ 2013] — [\[discussion on HN\]][discussion on HN]  
\[73\] [http://lkcl.net/reports/ssd\_analysis.html][http_lkcl.net_reports_ssd_analysis.html] — [\[discussion on HN\]][discussion on HN 1]

[Link 1]: http://blog.jobbole.com/
[Link 2]: http://www.jobbole.com/members/cugbabyebar
[Emmanuel Goossaert _CodeCapsule.com]: http://codecapsule.com/2014/02/12/coding-for-ssds-part-1-introduction-and-table-of-contents/
[Link 3]: http://group.jobbole.com/category/feedback/trans-team/
[Link 4]: http://codecapsule.com/2012/11/07/ikvs-implementing-a-key-value-store-table-of-contents/
[Link 5]: http://codecapsule.com/2014/02/12/coding-for-ssds-part-6-a-summary-what-every-programmer-should-know-about-solid-state-drives/
[Link 6]: http://blog.jobbole.com/63520/
[SSD]: http://blog.jobbole.com/63881/
[Link 7]: http://blog.jobbole.com/65583/
[Link 8]: http://blog.jobbole.com/67603/
[Link 9]: http://blog.jobbole.com/69815
[Link 10]: http://blog.jobbole.com/69969/
[Link 11]: http://codecapsule.com/2014/02/12/coding-for-ssds-part-2-architecture-of-an-ssd-and-benchmarking/
[7cc829d3gw1ef85q6kljgj20k00botan.jpg]: /images/20220722/f547d7e927b0470aa2138cbdbbdcab56.png
[31]: http://blog.jobbole.com/63881/#ref
[7cc829d3gw1ef85q7sue8j20k00bimyd.jpg]: /images/20220722/9121a00ecd084e19aae15101aeaba803.png
[7cc829d3gw1ef85q8qf2bj20k00a63zm.jpg]: /images/20220722/707758c39d71406791d724c82afcd2df.png
[7cc829d3gw1ef85q9dhluj20k00detbp.jpg]: /images/20220722/e3727c9640ce45c6b48d8c4470774dcf.png
[7cc829d3gw1ef85qaoqocj20k005s750.jpg]: /images/20220722/93d82b6b83864f6f867eed45820d63da.png
[7cc829d3gw1ef85qb8fwhj20k00cggn8.jpg]: /images/20220722/25c6637e51154fe29852b1a1a78fc366.png
[7cc829d3gw1ef85qcnrakj20k00n1jvm.jpg]: /images/20220722/9d93de4b76ed4345ba47de73ccc5002c.png
[Understanding Intrinsic Characteristics and System Implications of Flash Memory based Solid State Drives_ Chen et al._ 2009]: http://www.cse.ohio-state.edu/hpcs/WWW/HTML/publications/papers/TR-09-2.pdf
[Parameter-Aware I_O Management for Solid State Disks _SSDs_ Kim et al._ 2012]: http://csl.skku.edu/papers/CS-TR-2010-329.pdf
[Essential roles of exploiting internal parallelism of flash memory based solid state drives in high-speed data processing_ Chen et al_ 2011]: http://bit.csc.lsu.edu/~fchen/paper/papers/hpca11.pdf
[Exploring and Exploiting the Multilevel Parallelism Inside SSDs for Improved Performance and Endurance_ Hu et al._ 2013]: http://ieeexplore.ieee.org/xpls/abs_all.jsp?arnumber=6165265
[Design Tradeoffs for SSD Performance_ Agrawal et al._ 2008]: http://research.microsoft.com/pubs/63596/usenix-08-ssd.pdf
[Design Patterns for Tunable and Efficient SSD-based Indexes_ Anand et al._ 2012]: http://instartlogic.com/resources/research_papers/aanand-tunable_efficient_ssd_indexes.pdf
[BPLRU_ A Buffer Management Scheme for Improving Random Writes in Flash Storage_ Kim et al._ 2008]: https://www.usenix.org/legacy/events/fast08/tech/full_papers/kim/kim.pdf
[SFS_ Random Write Considered Harmful in Solid State Drives_ Min et al._ 2012]: https://www.usenix.org/legacy/event/fast12/tech/full_papers/Min.pdf
[A Survey of Flash Translation Layer_ Chung et al._ 2009]: http://idke.ruc.edu.cn/people/dazhou/Papers/AsurveyFlash-JSA.pdf
[A Reconfigurable FTL _Flash Translation Layer_ Architecture for NAND Flash-Based Applications_ Park et al._ 2008]: http://idke.ruc.edu.cn/people/dazhou/Papers/a38-park.pdf
[Reliably Erasing Data From Flash-Based Solid State Drives_ Wei et al._ 2011]: https://www.usenix.org/legacy/event/fast11/tech/full_papers/Wei.pdf
[http_en.wikipedia.org_wiki_Solid-state_drive]: http://en.wikipedia.org/wiki/Solid-state_drive
[http_en.wikipedia.org_wiki_Write_amplification]: http://en.wikipedia.org/wiki/Write_amplification
[http_en.wikipedia.org_wiki_Flash_memory]: http://en.wikipedia.org/wiki/Flash_memory
[http_en.wikipedia.org_wiki_Serial_ATA]: http://en.wikipedia.org/wiki/Serial_ATA
[http_en.wikipedia.org_wiki_Trim_computing]: http://en.wikipedia.org/wiki/Trim_%28computing%29
[http_en.wikipedia.org_wiki_IOPS]: http://en.wikipedia.org/wiki/IOPS
[http_en.wikipedia.org_wiki_Hard_disk_drive]: http://en.wikipedia.org/wiki/Hard_disk_drive
[http_en.wikipedia.org_wiki_Hard_disk_drive_performance_characteristics]: http://en.wikipedia.org/wiki/Hard_disk_drive_performance_characteristics
[http_centon.com_flash-products_chiptype]: http://centon.com/flash-products/chiptype
[http_www.thessdreview.com_our-reviews_samsung-64gb-mlc-ssd]: http://www.thessdreview.com/our-reviews/samsung-64gb-mlc-ssd/
[http_www.anandtech.com_show_7594_samsung-ssd-840-evo-msata-120gb-250gb-500gb-1tb-review]: http://www.anandtech.com/show/7594/samsung-ssd-840-evo-msata-120gb-250gb-500gb-1tb-review
[http_www.anandtech.com_show_6337_samsung-ssd-840-250gb-review_2]: http://www.anandtech.com/show/6337/samsung-ssd-840-250gb-review/2
[http_www.storagereview.com_ssd_vs_hdd]: http://www.storagereview.com/ssd_vs_hdd
[http_www.storagereview.com_wd_black_4tb_desktop_hard_drive_review_wd4003fzex]: http://www.storagereview.com/wd_black_4tb_desktop_hard_drive_review_wd4003fzex
[http_www.storagereview.com_samsung_ssd_840_pro_review]: http://www.storagereview.com/samsung_ssd_840_pro_review
[http_www.storagereview.com_micron_p420m_enterprise_pcie_ssd_review]: http://www.storagereview.com/micron_p420m_enterprise_pcie_ssd_review
[http_www.storagereview.com_intel_x25-m_ssd_review]: http://www.storagereview.com/intel_x25-m_ssd_review
[http_www.storagereview.com_seagate_momentus_xt_750gb_review]: http://www.storagereview.com/seagate_momentus_xt_750gb_review
[http_www.storagereview.com_corsair_vengeance_ddr3_ram_disk_review]: http://www.storagereview.com/corsair_vengeance_ddr3_ram_disk_review
[http_arstechnica.com_information-technology_2012_06_inside-the-ssd-revolution-how-solid-state-disks-really-work]: http://arstechnica.com/information-technology/2012/06/inside-the-ssd-revolution-how-solid-state-disks-really-work/
[http_www.anandtech.com_show_2738]: http://www.anandtech.com/show/2738
[http_www.anandtech.com_show_2829]: http://www.anandtech.com/show/2829
[http_www.anandtech.com_show_6489]: http://www.anandtech.com/show/6489
[http_lwn.net_Articles_353411]: http://lwn.net/Articles/353411/
[http_us.hardware.info_reviews_4178_10_hardwareinfo-tests-lifespan-of-samsung-ssd-840-250gb-tlc-ssd-updated-with-final-conclusion-final-update-20-6-2013]: http://us.hardware.info/reviews/4178/10/hardwareinfo-tests-lifespan-of-samsung-ssd-840-250gb-tlc-ssd-updated-with-final-conclusion-final-update-20-6-2013
[http_www.anandtech.com_show_6489_playing-with-op]: http://www.anandtech.com/show/6489/playing-with-op
[http_www.ssdperformanceblog.com_2011_06_intel-320-ssd-random-write-performance]: http://www.ssdperformanceblog.com/2011/06/intel-320-ssd-random-write-performance/
[http_en.wikipedia.org_wiki_Native_Command_Queuing]: http://en.wikipedia.org/wiki/Native_Command_Queuing
[http_superuser.com_questions_228657_which-linux-filesystem-works-best-with-ssd]: http://superuser.com/questions/228657/which-linux-filesystem-works-best-with-ssd/
[http_blog.superuser.com_2011_05_10_maximizing-the-lifetime-of-your-ssd]: http://blog.superuser.com/2011/05/10/maximizing-the-lifetime-of-your-ssd/
[http_serverfault.com_questions_356534_ssd-erase-block-size-lvm-pv-on-raw-device-alignment]: http://serverfault.com/questions/356534/ssd-erase-block-size-lvm-pv-on-raw-device-alignment
[http_rethinkdb.com_blog_page-alignment-on-ssds]: http://rethinkdb.com/blog/page-alignment-on-ssds/
[http_rethinkdb.com_blog_more-on-alignment-ext2-and-partitioning-on-ssds]: http://rethinkdb.com/blog/more-on-alignment-ext2-and-partitioning-on-ssds/
[http_rickardnobel.se_storage-performance-iops-latency-throughput]: http://rickardnobel.se/storage-performance-iops-latency-throughput/
[http_www.brentozar.com_archive_2013_09_iops-are-a-scam]: http://www.brentozar.com/archive/2013/09/iops-are-a-scam/
[http_www.acunu.com_2_post_2011_08_why-theory-fails-for-ssds.html]: http://www.acunu.com/2/post/2011/08/why-theory-fails-for-ssds.html
[http_security.stackexchange.com_questions_12503_can-wiped-ssd-data-be-recovered]: http://security.stackexchange.com/questions/12503/can-wiped-ssd-data-be-recovered
[http_security.stackexchange.com_questions_5662_is-it-enough-to-only-wipe-a-flash-drive-once]: http://security.stackexchange.com/questions/5662/is-it-enough-to-only-wipe-a-flash-drive-once
[http_searchsolidstatestorage.techtarget.com_feature_The-truth-about-SSD-performance-benchmarks]: http://searchsolidstatestorage.techtarget.com/feature/The-truth-about-SSD-performance-benchmarks
[http_www.theregister.co.uk_2012_12_03_macronix_thermal_annealing_extends_life_of_flash_memory]: http://www.theregister.co.uk/2012/12/03/macronix_thermal_annealing_extends_life_of_flash_memory/
[http_www.eecs.berkeley.edu_rcs_research_interactive_latency.html]: http://www.eecs.berkeley.edu/~rcs/research/interactive_latency.html
[http_blog.nuclex-games.com_2009_12_aligning-an-ssd-on-linux]: http://blog.nuclex-games.com/2009/12/aligning-an-ssd-on-linux/
[http_www.linux-mag.com_id_8397]: http://www.linux-mag.com/id/8397/
[http_tytso.livejournal.com_2009_02_20]: http://tytso.livejournal.com/2009/02/20/
[https_wiki.debian.org_SSDOptimization]: https://wiki.debian.org/SSDOptimization
[http_wiki.gentoo.org_wiki_SSD]: http://wiki.gentoo.org/wiki/SSD
[https_wiki.archlinux.org_index.php_Solid_State_Drives]: https://wiki.archlinux.org/index.php/Solid_State_Drives
[https_www.kernel.org_doc_Documentation_block_cfq-iosched.txt]: https://www.kernel.org/doc/Documentation/block/cfq-iosched.txt
[http_www.danielscottlawrence.com_blog_should_i_change_my_disk_scheduler_to_use_NOOP.html]: http://www.danielscottlawrence.com/blog/should_i_change_my_disk_scheduler_to_use_NOOP.html
[http_www.phoronix.com_scan.php_page_article_item_linux_iosched_2012]: http://www.phoronix.com/scan.php?page=article&item=linux_iosched_2012
[http_www.velobit.com_storage-performance-blog_bid_126135_Effects-Of-Linux-IO-Scheduler-On-SSD-Performance]: http://www.velobit.com/storage-performance-blog/bid/126135/Effects-Of-Linux-IO-Scheduler-On-SSD-Performance
[http_www.axpad.com_blog_301]: http://www.axpad.com/blog/301
[http_en.wikipedia.org_wiki_List_of_solid-state_drive_manufacturers]: http://en.wikipedia.org/wiki/List_of_solid-state_drive_manufacturers
[http_en.wikipedia.org_wiki_List_of_flash_memory_controller_manufacturers]: http://en.wikipedia.org/wiki/List_of_flash_memory_controller_manufacturers
[http_blog.zorinaq.com_e_29]: http://blog.zorinaq.com/?e=29
[http_www.gamersnexus.net_guides_956-how-ssds-are-made]: http://www.gamersnexus.net/guides/956-how-ssds-are-made
[http_www.gamersnexus.net_guides_1148-how-ram-and-ssds-are-made-smt-lines]: http://www.gamersnexus.net/guides/1148-how-ram-and-ssds-are-made-smt-lines
[http_www.tweaktown.com_articles_4655_kingston_factory_tour_making_of_an_ssd_from_start_to_finish_index.html]: http://www.tweaktown.com/articles/4655/kingston_factory_tour_making_of_an_ssd_from_start_to_finish/index.html
[http_www.youtube.com_watch_v_DvA9koAMXR8]: http://www.youtube.com/watch?v=DvA9koAMXR8
[http_www.youtube.com_watch_v_3s7KG6QwUeQ]: http://www.youtube.com/watch?v=3s7KG6QwUeQ
[Understanding the Robustness of SSDs under Power Fault_ Zheng et al._ 2013]: https://www.usenix.org/conference/fast13/technical-sessions/presentation/zheng
[discussion on HN]: https://news.ycombinator.com/item?id=7047118
[http_lkcl.net_reports_ssd_analysis.html]: http://lkcl.net/reports/ssd_analysis.html
[discussion on HN 1]: https://news.ycombinator.com/item?id=6973179
[7cc829d3gw1efqfq6pr4bj20k00e1myw.jpg]: /images/20220722/fd1704925f074b0d8bf87b35c911eca0.png
[7cc829d3gw1efqfq7ix13j20k00l5q5e.jpg]: /images/20220722/2071cf624b5d4804ae653e7596119a92.png
[13]: http://codecapsule.com/2014/02/12/coding-for-ssds-part-3-pages-blocks-and-the-flash-translation-layer/#ref
[7cc829d3gw1efqfq8owefj20k00s1djy.jpg]: /images/20220722/58741871dce6400cbc4559661261a081.png
[16]: http://codecapsule.com/2014/02/12/coding-for-ssds-part-4-advanced-functionalities-and-internal-parallelism/#ref
[7cc829d3gw1eg9igt3kjqj20k00o3ju7.jpg]: /images/20220722/f3aafd57d32241cd9f6d0bac39aad123.png
[7cc829d3gw1egyxsils2tj20k00g3go1.jpg]: /images/20220722/fedbbb14d6314c8ea4aeb47da99c8d79.png
[2]: http://codecapsule.com/2014/02/12/coding-for-ssds-part-5-access-patterns-and-system-optimizations/#ref
[7cc829d3gw1egyxskiqvyj20k00h9wgb.jpg]: /images/20220722/1658988098c94477ad529ef1c4b80e77.png
[7cc829d3gw1egyxsma5avj20k00d8ac6.jpg]: /images/20220722/1f11530167374551b017fe6eaeb2b67f.png
[7cc829d3gw1egyxsoenuej20k00w6431.jpg]: /images/20220722/996f336ae8a3402f952632c5c80553e0.png
[_7.3]: http://blog.jobbole.com/?p=69815
[FAST 2013]: https://www.usenix.org/conference/fast13
[FAST 2014]: https://www.usenix.org/conference/fast14
[ssd-presentation-02]: /images/20220722/1bd3bf3c0b714516aa1ba2474b55f730.png
[31 1]: http://codecapsule.com/2014/02/12/coding-for-ssds-part-2-architecture-of-an-ssd-and-benchmarking/#ref
[ssd-architecture]: /images/20220722/11857418ecc74154abc7caad4d28c2e8.png
[samsungssd840pro-01]: /images/20220722/7e58eb78ac084d13a1452336e7951d1d.png
[samsungssd840pro-02]: /images/20220722/eaf83443777b414d88b3adb79d5e42d8.png
[micron-p420m-01]: /images/20220722/c6b33234cf814b028da68219204eb8ac.png
[micron-p420m-02]: /images/20220722/4f1179e6ac3045f693fd22d893f3e956.png
[writes-preconditioning]: /images/20220722/47140204052c4a3084267253353bab8f.png
[here]: http://codecapsule.com/2014/02/12/coding-for-ssds-part-3-pages-blocks-and-the-flash-translation-layer/
[translated to Simplified Chinese]: http://blog.xiongduo.cn/IT-Trans/coding-for-ssds-part-2-architecture-of-an-ssd-and-benchmarking.html