System and method for high performance command processing in solid state drives

[0001] 1. Technical Field

[0002] This disclosure relates to non-volatile storage subsystems, including but not limited to flash drives. More particularly, the disclosure relates to systems and methods for high performance command processing in solid state drives.

[0003] 2. Description of the Related Art

[0004] Flash media used in solid-state storage systems can provide a very high bandwidth. However, processing delays for incoming commands can be a cause of perceptible delays from the host. Typical command processing interprets commands via a data path that does not take advantage of the concurrency offered by the flash media in solid-state storage systems. A system that can process multiple read and write commands from the host and quickly pass these commands to the storage media back end can improve processing performance and reduce delay.

[0010] While certain embodiments of the inventions are described, these embodiments are presented by way of example only, and are not intended to limit the scope of the inventions. Indeed, the novel methods and systems described herein may be embodied in a variety of other forms. Furthermore, various omissions, substitutions and changes in the form of the methods and systems described herein may be made without departing from the spirit of the inventions.

Overview

[0011] Solid State Drives (SSD) can yield very high performance if it is designed properly. A SSD typically includes both a front end that interfaces with the host and a back end that interfaces with the flash media. Typically SSDs include flash media that is designed with a high degree of parallelism that can support a very high bandwidth on input/output (I/O). A SSD front end designed according to a traditional hard disk drive (HDD) model will not be able to take advantage of the high performance offered by the typical flash media. Embodiments of the invention provide improved management of multiple I/O threads that take advantage of the high performing and concurrent nature of the back end media, so the resulting storage system can achieve a very high performance.

System Overview

[0012] Embodiments of the invention are directed to systems and methods for providing a high performance data path on a solid-state storage system. As used in this application, “non-volatile memory” typically refers to solid-state memory such as NAND flash. However, the systems and methods of this disclosure may also be useful in more conventional hard drives and hybrid drives including both solid-state and hard drive components. As such, while certain internal operations are referred to which typically are associated with solid-state drives, such as “wear leveling” and “garbage collection,” analogous operations for hard drives can also take advantage of this disclosure. Solid-state memory may comprise a wide variety of technologies, such as flash integrated circuits, Chalcogenide RAM (C-RAM), Phase Change Memory (PC-RAM or PRAM), Programmable Metallization Cell RAM (PMC-RAM or PMCm), Ovonic Unified Memory (OUM), Resistance RAM (RRAM), NAND memory, NOR memory, EEPROM, Ferroelectric Memory (FeRAM), or other discrete NVM (non-volatile memory) chips. The solid-state storage devices may be physically divided into planes, blocks, pages, and sectors, as is known in the art. Other forms of storage (e.g., battery backed-up volatile DRAM or SRAM devices, magnetic disk drives, etc.) may additionally or alternatively be used.

[0013] FIG. 1 shows an embodiment of a solid-state non-volatile storage system 100 connected to a host device 110. The host device 110 communicates with a host interface 104 of the non-volatile storage system 100 using a host storage interface 111. The host storage interface 111 can communicate with the host interface 104 using any known communication protocol, such as SATA, SCSI, SAS, USB, Fibre Channel, PCIe, eMMC, etc. In one embodiment, the communication protocol allows for the use of tagged commands, such that multiple read and/or write commands may be pending on the storage system simultaneously. Tagged commands can include tagged command queuing and native command queuing tags.

[0014] In one embodiment, host commands are received by the host interface 104 and are processed. The host interface may be implemented as an Interface Assist Processor (IAP). The host interface in one embodiment is implemented as firmware on a processor (e.g., SoC) that may also implement a number of other components that make up part or all of a front end 102. For example, as shown, the front end includes a number of high performance path components 103 and standard performance path components 105.

[0015] When a command is received in the host interface 104, the host interface processes the command by determining whether the command should be handled via a high performance path (through its associated components 103) or a standard performance path (through its associated components 105). The processing may additionally involve parsing of the incoming command such as determining command type, logical address for the command, size of data to be transferred, etc.

[0016] In one embodiment, regardless of whether the command is processed via the high performance or standard performance path, the host interface 104 sends instructions based on the command to the back end components 120, which are tasked with processing the instructions by sending the appropriate media access requests to the media 128. For example, the front end may provide to the back end instructions for a read command, and the instructions may include a logical address and a command size of the read command. The back end may then process the instructions by issuing requests to the media to fulfill the instructions. In one embodiment, a data manager module 123 is tasked with processing the instructions from the host interface 104. The data manager module 123 may perform additional processing, such as performing mapping table lookups and issuing media access requests to the media 128. The data manager module 123 also provides status updates back to the front end (including, for example, the host interface 104) indicating whether the requests were completed successfully or not.

[0017] In one embodiment, the requests may be handled via the use of media access request objects 124, which are managed by a media access request manager 126. The media access request objects are executed in the media 128 by a media access request executor 126. A separate component 122 may also issue data access requests related to internal maintenance operations such as garbage collection and wear leveling. In other embodiments, the data manager module 123, the media access request manager 125, and the media access request executor 126 may be combined into one module that manages data access requests to the media. Each of these modules may be implemented as firmware on one or more processors and/or as dedicated hardware (e.g., System on Chip (SoC)).

Data Control Structures and Associated Buffer Allocations

[0018] In one embodiment, if the command is to be processed via the high performance path, the host interface 104 is configured to communicate instructions to the data manager module 123 via a number of data control structures, which in one embodiment are memory objects stored in volatile memory 108. The volatile memory 108 may be implemented as DRAM (Dynamic Random Access Memory), for example, and in one embodiment this volatile memory is configured to be accessed by both the front end and the back end, and in particular, the host interface 104 and the data manager 123. Additional details regarding the data control structures will be provided in conjunction with FIG. 4 below. Alternatively, if the command is sent via the standard performance path, which in one embodiment processes one command at a time, a single data control structure may be used to process the command. In another embodiment, along the standard performance path, the instructions regarding the command may be sent to the back end without the use of a data control structure.

[0019] On the high performance path, the data control structures serve as conduits through which communications are facilitated between the front end 102 and the back end 120, and in particular, between the host interface 104 and the data manager module 123. This greatly improves performance as instructions from the front end to the back end no longer needs to be copied, which is typically performed in prior implementations. In particular, the use of a common RAM area across the front end and the back end to hold common data control structures means that the system needs to populate the I/O control information in the data control structures once, and does not need to perform the same tasks twice (once in the front end and once in the back end). In one embodiment, the data control structures can be used across the entire system. For example, nexus information can be used for both front end and back end for command processing, error handling, command completion, etc. This use of common data control structures throughout the storage system 100 thus reduces the overall command processing overhead. These data control structures also allow for improved concurrent processing of multiple commands in the storage system.

[0020] In one embodiment, the data control structures can each be independently updated by either the host interface 104 or the data manger module 123. In one embodiment, the number of data control structures matches a number of commands that can be processed at a time in the non-volatile storage system 100. For example, a system using a SATA interface may have a maximum of 32 tagged commands, and in that embodiment, the volatile memory includes 32 pre-allocated data control structures to enable servicing of the entire range of tagged commands without delay. In other embodiments such as SAS where the maximum number of commands is 128, the number of data control structures may be less than the maximum number, or may match the maximum number, if a larger volatile memory is used to store the data control structures and a larger data buffer is used to store data to be transferred between the host and the media.

[0021] In one embodiment, the storage system includes a buffer 101 for temporary storage of data to be written to, and/or to be read from, the solid state media 128. In one embodiment, each data control structure is associated with a designated buffer allocation within the buffer 101. Thus, in the example above where there are 32 data control structures, 32 designated buffer allocations may be provided, so that each of the 32 data control structures has a designated buffer allocation associated with it.

[0022] In one embodiment, the buffer allocations are reused by the data control structures. For example, a particular buffer allocation may consistently be used with a data control structure. With the pre-set data control structures and pre-set buffer allocations, the system does not need to allocate resources to process the incoming commands upon their arrival. Conversely, after the commands are completed, the system does not need to de-allocate resources. The data control structures and buffer allocations are simply re-used for the next set of new commands from the host. This reduces the per-command processing overhead, as well as provides both the front end and the back end an efficient way to handle multiple commands at the same time.

[0023] The use of the data control structures enables the system to arm for random commands. Sequential automation (automating processing of sequential commands) is commonly performed in many hard disk storage controllers to increase performance. However, random automation (automating processing of random commands) is not commonly performed. In various embodiments of the invention, random automation is performed as follows. Prior to a command arriving from the host, the data manager module sets up certain data control structures and performs other preparatory tasks such as setting flags and preparing for queuing. Therefore, once a command arrives from the host with the logical address information, minimal additional processing needs to be done and the command can be processed quickly. In one embodiment, some or all of the data control structures are pre-configured to handle a command with a certain data size (e.g., 128 kb), so that when a random read or write command of that data size (or smaller) arrives, the above discussed pre-processing can be leveraged and the command can be processed quickly. This improves the random IOPS for the overall system. In one embodiment, an “over-sized” command that is beyond the data size (e.g., 256 sectors or 128 kb) may be sent via the standard performance path for processing. As discussed above, the standard performance path may handle one command at a time as supposed to the concurrent multiple-command processing capability of the high performance path. Other internal storage system commands that are not as performance sensitive as the host-issued ones may also be handled via the standard performance path.

Command Process Flow

[0024] FIG. 2 is a flow diagram showing the processing of data access commands according to an embodiment. The process flow 200 is illustrated in two concurrent phases: a command phase and a data phase. In the command phase, in block 202, a command is first received from the host. The host interface 104 then parses the command and builds out the data control structure for the command in block 204. In block 206, the data manager module then checks for the new data control structure and performs processing based on information in the data control structure in block 208. The processing may include performing mapping table updates and readying requests to the media to fulfill the execution of the command. Then, in block 220, the request(s) to fulfill the command are sent to the media. In one embodiment, for a write command, the action in block 220 is performed when the data to be written has been fully received from the host (see block 216), though in other embodiments the action can be performed concurrently with the receiving of the write data (i.e., prior to the receipt of all the write data). Although not shown, the data manager module may afterwards write updates back to the data control structure to indicate whether the request(s) to the media were completed successfully.

[0025] Concurrent to the above process in the data phase are a number of processing steps in the data phase. After the command is received, the data manager module and/or the host interface obtains the next available buffer space for data to be transferred for the command. If the command is a write command, at block 214 data is received from the host. This is performed while the processing is done on the command phase side, so that concurrency can be maximized. At block 216, the actual writing of the data starts as soon as the data is transferred from host, at which point the write requests are dispatched to the media. The dedicated buffer in the storage system allows the data transfer to occur concurrently with the command processing. In this manner, the command processing time can overlap with the host data transfer time, thus enabling the system to take full advantage of the high bandwidth offered by the solid-state media. Alternatively, if the command is a read command, the data read from the media is transferred into the buffer when the read request(s) fulfilling the read command are dispatched to the media (block 218).

Coalescing Updates from the Media

[0026] FIG. 3 is a flow diagram 300 showing the process of coalescing updates from the media and bundling updates for reporting to the data control structures according to an embodiment. As discussed above, the system manages multiple active I/O data threads, with each being tracked by a data control structure. In one embodiment, the multiple I/O data threads are concurrently dispatched to the media firmware, and the back end components such as the data manager module handles coherency, data transfer, and command completion according to those multiple I/O threads. This is done so that the media is kept as busy as possible. In the flow diagram 300, the data manager 123 (or another back end component) dispatches data access requests to multiple devices (e.g., dies) on the media in block 302. Then the updates (e.g., completion status, error status) from the devices are coalesced in block 304. In block 306, the associated data control structures are updated according to the coalesced updates. The process of coalescing can arrange updates that arrive from the media out of order. For example, a write command may be associated with eight requests Nos. 1-8 to eight dies on the media, and due to the nature of the dies in the media certain requests may complete first. In this example, the completion statuses for dies Nos. 5-8 may arrive from the media at the data manger module before those from dies Nos. 1-4. Such updates may be bundled together into a single status update to the associated data control structure.

Data Control Structures

[0027] FIG. 4 illustrates example data control structures according to an embodiment. The figure shows two example data control structures 402 and 404. However, as discussed above, the system may have a sufficient number of data control structures to match a number of concurrent commands that can be processed by the system at one time. In each example data control structure shown, there are fields such as command ID, command type, logical block address (LBA), command size, physical block address (PBA), status, and a buffer ID. As also discussed previously, each data control structure has an associated buffer allocation, and the buffer ID may be used to indicate, or point to, the associated buffer allocation. As shown in FIG. 4, the host interface and the data manger module can each access and update the individual data control structures so that the commands associated with the structures can be tracked. In one embodiment, the system supports pre-arming of these data control structures, i.e., some of the fields are pre-filled prior to command arrival from the host. For example, the command size field may be pre-set to 128 kb for some or all of the data control structures, so that when a new command of that size or smaller arrives from the host, the host interface can use any available data control structure with those pre-set fields and its associated buffer allocation (which has already been pre-allocated). In this manner, the host interface can parse the command and fill in the remaining fields (e.g., LBA) and the command can be dispatched to the back end for the data manager for additional processing.

[0028] In one embodiment, for sequential large transfer, the system bundles the updates within the command. For example, if the system is writing two chunks of data within the command, the system updates the mapping information for those two chunks at once. This is done to reduce overhead of command processing time.

[0029] While certain embodiments of the inventions have been described, these embodiments have been presented by way of example only, and are not intended to limit the scope of the inventions. Indeed, the novel methods and systems described herein may be embodied in a variety of other forms. Furthermore, various omissions, substitutions and changes in the form of the methods and systems described herein may be made without departing from the spirit of the inventions. The accompanying claims and their equivalents are intended to cover such forms or modifications as would fall within the scope and spirit of the inventions. For example, the various components illustrated in FIG. 1 may be implemented as software and/or firmware on a processor or ASIC or as dedicated hardware. For example, those skilled in the art will appreciate that in various embodiments, the actual steps taken in the processes shown in FIG. 2 may differ from those shown in the figures. Depending on the embodiment, certain of the steps described in the example above may be removed, others may be added, and the sequence of steps may be altered and/or performed in parallel. Although this disclosure describes examples in which data are stored in groups of blocks termed superblocks, those skilled in the art will recognize that the various embodiments disclosed are applicable to systems with other memory measurement units such as planes, blocks, pages, sectors, etc. Also, the features and attributes of the specific embodiments disclosed above may be combined in different ways to form additional embodiments, all of which fall within the scope of the present disclosure. Although the present disclosure provides certain preferred embodiments and applications, other embodiments that are apparent to those of ordinary skill in the art, including embodiments which do not provide all of the features and advantages set forth herein, are also within the scope of this disclosure. Accordingly, the scope of the present disclosure is intended to be defined only by reference to the appended claims.