Systems, methods, and apparatus for using commit queues for write buffer utilization
By introducing a queue management mechanism in the storage device, arranging write requests by FIFO and processing when the write buffer is available, the problem of underutilization of the write buffer is solved and the performance of the storage device is improved.
Patent Information
- Application Number
- CN202410616854.6
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- Priority Date
- 2024-05-01
- Filing Date
- 2024-05-17
- Publication Date
- 2024-11-22
AI Technical Summary
When processing write requests, the write buffer of the storage device is often not fully utilized due to waiting for other write buffers to free up space, resulting in reduced efficiency.
By introducing a queue management mechanism in the storage device, write requests are arranged in a first-in-first-out (FIFO) queue, and requests are processed step by step when the write buffer is available, avoiding waiting for other write buffers to free up space and improving write buffering The utilization rate of the device.
It effectively improves the utilization rate of write buffers, reduces waiting time, and improves the overall performance of storage devices.
Smart Images

Figure CN119002798A_ABST
Abstract
Description
Technical Field
[0001] The present disclosure relates generally to storage devices, and more particularly to systems, methods, and apparatus for improving write buffer utilization on storage devices. Background Art
[0002] Typically, a storage device may include a write buffer that interacts with a host to allow writing to a storage medium on the storage device. The host may pass a write request to the storage device, which may be written to the write buffer. Data from the write buffer may be written to the storage medium, and a completion message may be returned to the host indicating that the data has been written to the storage device.
[0003] The above information disclosed in this Background section is only for enhancement of understanding of the background of the invention and therefore it may contain information that does not constitute prior art. Summary of the invention
[0004] In some aspects, the description herein relates to a method, comprising: receiving a first request from a host device to write first data to a memory device; adding the first request to a queue on the memory device; determining the availability of a write buffer of the memory device; retrieving the first data from the host device based on the determination and the first request added to the queue; and writing the first data to the write buffer of the memory device. The method may also include: returning a completion message to the host device based on writing the first data to the write buffer; and writing the first data from the write buffer of the memory device to a storage medium. The first request may be an SQE, and the method may also include parsing the SQE and determining that the SQE is a write command. The method may also include: parsing a reclaim group (RG) and a reclaim unit handle (RUH) from the SQE; and adding the first request to the queue may include queuing the SQE in a first-in-first-out (FIFO) queue, wherein the FIFO queue corresponds to the RG and the RUH. Adding the first request to the queue may include determining that the size of the data in the write buffer is above a threshold; and adding the first data to the queue. Determining the availability of the write buffer may include determining that the size of the data in the write buffer is below a threshold; and writing the first data to the write buffer may include writing the first data from a queue to the write buffer; and removing the first data from the queue. The queue may include a first indicator, wherein the first indicator may correspond to a location in a host memory of the host device, wherein the location in the host memory corresponds to the first data. The method may also include: receiving a second request from the host device to read second data from the memory device; and retrieving the second data from the memory device; wherein the write buffer is above the threshold. The method may also include: receiving a second request from the host device to write the second data to the memory device; and adding the second request to the queue on the memory device. The method may also include a second indicator, wherein the second indicator corresponds to the most recent first request.
[0005] In some aspects, the description herein relates to a device including a controller, wherein the controller includes a write buffer; a storage medium; and a queue; and wherein the controller performs an operation, the operation including: receiving a first request from a host device to write first data to a storage medium; adding the first request to a queue, wherein the queue is a FIFO queue; retrieving the first data from the host device based on the first request; determining the availability of a write buffer of a memory device; retrieving the first data from the host device based on the determination and the first request added to the queue; writing the first data to the write buffer; returning a completion message to the host device; and writing the first data from the write buffer to the storage medium. The first request may be an SQE, the completion message may be a completion queue entry (CQE), and the controller may further perform an operation including parsing the SQE and determining that the SQE is a write request. Parsing the SQE may include parsing an RG and a RUH from the SQE, wherein the queue corresponds to the RG and the RUH. Adding the first request to the queue may include determining that the size of the data in the write buffer is above a threshold, and adding the first data to the queue. Writing the first data to the write buffer may include determining that the size of the data in the write buffer is below a threshold, writing the first data from the queue to the write buffer, and removing the first data from the queue. The controller may perform operations including receiving a second request from the host device to write second data to the storage medium and adding the second request to a queue, and writing the first data to the write buffer may include determining that a size of the data in the write buffer is below a threshold, writing the first data from the queue to the write buffer, and writing the second data from the queue to the write buffer. The queue may include a first indicator, wherein the first indicator corresponds to a location in a host memory of the host device, and the location in the host memory corresponds to the first data.
[0006] In some aspects, the description herein relates to a system comprising: a host device; and a storage device, wherein the storage device comprises a controller, wherein the controller comprises a write buffer; a storage medium; and a queue; wherein the controller can perform operations comprising: receiving a first request from the host device to write first data to the storage medium; adding the first request to the queue, wherein the queue is a FIFO queue; determining the availability of the write buffer of the memory device; retrieving the first data from the host device based on the determination and the first request added to the queue; writing the first data to the write buffer; returning a completion message to the host device; and writing the first data from the write buffer to the storage medium. Adding the first request to the queue may include determining that the size of the data in the write buffer is above a threshold, and adding the first request to the queue. Writing the first data to the write buffer may include determining that the size of the data in the write buffer is below a threshold, writing the first data from the queue to the write buffer, and removing the first data from the queue. BRIEF DESCRIPTION OF THE DRAWINGS
[0007] The drawings are not necessarily drawn to scale, and throughout the drawings, for illustrative purposes, elements of similar structure or function may generally be represented by the same reference numerals or portions thereof. The drawings are intended only to facilitate the description of the various embodiments described herein. The drawings do not describe every aspect of the teachings disclosed herein and do not limit the scope of the claims. In order to prevent the drawings from becoming obscure, not all components, connections, etc. may be shown, and not all components may be shown with reference numerals. However, the mode of component configuration can be easily apparent from the drawings. The drawings, together with the specification, illustrate example embodiments of the present disclosure and, together with the specification, are used to explain the principles of the present disclosure.
[0008] Figure 1 An example of a storage device using a write buffer according to an example embodiment of the present disclosure is shown.
[0009] Figure 2 Another example of a storage device using a write buffer according to an example embodiment of the present disclosure is shown.
[0010] Figure 3 A method for populating a storage medium according to an example embodiment of the present disclosure is shown.
[0011] Figure 4 An example operating environment for a host device to send a write request to a storage device according to an example embodiment of the present disclosure is shown.
[0012] Figure 5 A flow chart illustrating an example process for populating a storage medium according to an example embodiment of the present disclosure is shown. DETAILED DESCRIPTION
[0013] Typically, a storage device may be organized into blocks, and each block may contain one or more pages. In some embodiments, data may be written to and read from a storage device by page, and may be erased by block. In some embodiments, when data is deleted from a storage device, the data on the block may not be erased. For example, a solid-state drive (SSD) may delete references to data on a block, while the data remains on the block until an erase operation occurs.
[0014] In some embodiments, when data is to be written to a storage device, it may be necessary to write the data to an empty block. For example, in an SSD, before data can be written to a block, all cells on the block may need to be set to zero. However, if there is still data in use on the block, the data may need to be moved from the block before the new data can be written to the block. Otherwise, when a new write operation is performed on the block, the data on the block may be overwritten. Therefore, it may be necessary to write the existing data on the block to temporary storage. When the data is moved to temporary storage, the block can be erased because the data is located at the temporary storage. The data written to the temporary storage can then be written back to the free block.
[0015] In some embodiments, the host can control which logical blocks are written to a collection of blocks managed by the SSD, which is called a recovery unit (RU). For example, the host can use a recovery unit handle (RUH) pointing to a RU in the SSD. In particular, the RUH can allow the SSD to manage and buffer logical blocks to write to the RU. In some embodiments, the host can act on the RUH to write to the corresponding RU, thereby allowing the host to isolate the data written to the RU for each application or even within the application to separate write data with different life cycles (e.g., hot data and cold data). In some embodiments, a recovery group (RG) can be a collection of RUs. In some embodiments, the storage device can have a write buffer for each RG / RUH combination.
[0016] In some embodiments, a storage device may use a write buffer to write data to a storage medium. However, in some embodiments, the write buffer may not be able to write to the storage medium, for example, if the storage medium is in use or other data is being written to the storage medium. In some embodiments, if data from the write buffer is not written to the storage medium, a completion queue entry (CQE) may not be sent to the host, and the write buffer may not process another submission queue entry (SQE) until the CQE is sent. In addition, in some embodiments, a write buffer may not be fully utilized if it needs to wait for write data while other write buffers are being used.
[0017] According to an embodiment of the present disclosure, by filling the write buffer with a queue for write requests, the write buffer may be better utilized because the storage device may receive more requests while the queue waits until the write buffer can process additional write data transfers from the host.
[0018] Figure 1 An example of a storage device using a write buffer according to an example embodiment of the present disclosure is shown. Figure 1 In the example shown, the storage device includes an SSD 100 . Figure 1The SSD 100 in EMBODIMENT 1 includes a controller 110 and a storage medium, such as a die 120. The controller 110 includes a write buffer 112. In some embodiments, a write SQE (eg, a request to write data to a memory device) may be received by the controller 110 from a host 150. Figure 1 The host 150 in the embodiment includes a host memory 152, and the host memory 152 includes a submission queue 154. In some embodiments, the submission queue 154 may contain entries (e.g., SQEs) from the host 150 to write data to the SSD 100. In some embodiments, the SQEs may be read from the submission queue 154 and sent to the SSD 100. In some embodiments, the controller 110 may read and parse the SQEs to determine whether the SQEs are write requests. In some embodiments, if the SQEs are write requests, the data may be transferred to the write buffer 112. In some embodiments, the controller 110 may complete the write request by returning a CQE to the host 150. In some embodiments, the controller 110 may also program the data in the write buffer 112 to a storage medium, such as a die 120.
[0019] In some embodiments, the foregoing process may assume that the controller 110 selects a location for data storage and implements compact and orderly filing of storage media. Figure 1 The problem with the described process is that there may be one RG per die, and all commands may go to a single RG. Additionally, write buffer 112 may fill up because one die becomes busy. Therefore, in some embodiments, read commands submitted to submit queue 154 may be blocked, as well as write commands to another die (e.g., another RG).
[0020] Figure 2 Another example of a storage device using a write buffer according to an example embodiment of the present disclosure is shown. Figure 2 , the same reference numerals are used for the same components. Figure 2 A queue 200 is also included. The queue 200 is included in the controller 110. The controller 110 may use the queue 200 to receive a write request from the host 150 instead of transferring data from the SQE to the write buffer 112. The queue 200 is described in detail below. Figure 3 A method for filling a storage medium according to an example embodiment of the present disclosure is shown. Figure 2 and Figure 3 Further description is given.
[0021] At 310, a request is received at the controller 110 from the host 150. For example, in some embodiments, the host 150 may send a request (e.g., an SQE) that is received at the controller 110. In some embodiments, the SQE may be a write request (e.g., a request to write data from the host 150 to the SSD 100). It should be understood that the SQE need not come from the host, and may come from another source, such as the SSD itself or another SSD. Additionally, in some embodiments, the SQE need not be received, and another type of request to write data to the SSD may be received from the SSD.
[0022] At 320, the request is parsed. For example, in some embodiments, the controller 110 may determine whether the request is a write request. In some embodiments, if the request is a write request, the controller 110 may determine that the write request should be written to the memory. In some embodiments, the RG and RUH may be parsed from the write request. In some embodiments, the RG and RUH may correspond to the write buffer 112. It should be understood that the write buffer needs to correspond to the RG and RUH, and may correspond to the RG or the RUH. In addition, in some embodiments, the write buffer does not need to correspond to the RG or the RUH, and may correspond to any logical partition of the storage medium.
[0023] At 325, the SSD 100 determines whether the write buffer 112 is full. For example, in some embodiments, the controller 110 may determine whether the size of the data in the write buffer 112 is above a threshold. The threshold may be the size of a programming unit (e.g., one word line (WL) of one erase block (EB), one WL of one EB from each plane of a die, one WL of one EB for each die within a RG, etc.), or some other size. For example, the size of the write buffer 112 may be proportional to the size of the RG. In some embodiments, the amount of data in the write buffer may not be compared to a threshold, and some other method may be used to determine when to write data to the write buffer. For example, the SSD may use artificial intelligence to determine when the write buffer is full and / or the size of the data to be written.
[0024] At 330, when the write buffer 112 is full, the write request is queued. For example, the controller 110 may queue the write request in the queue 200 and then process additional commands. For example, the method may return to 310. When the controller 110 receives another write request, it may parse the write request (e.g., go to 320) and determine whether the write buffer 112 is full (e.g., go to 325). In some embodiments, when the write buffer 112 is not full, data from the write request may be transferred to the write buffer 112.
[0025] At 340, when the write buffer 112 is not full, the write request is dequeued from the queue 200 (e.g., the write request may be removed from the queue), and the data may be transferred to the write buffer 112. For example, if the write buffer 112 is not full (e.g., the data of the previous write request is in the write buffer 112 and is written to the die 120), the next write request may be obtained from the queue 200, and the next write request may be added to the write buffer 112. In some embodiments, the queue 200 may be a first-in-first-out (FIFO) queue, so that the oldest data is processed first. This may allow the write buffer 112 to process the requests in the order in which they are received, rather than the controller 110 processing the requests. Thus, in some embodiments, a write request may be received from the host 150 without waiting for the write buffer 112 to free up space for more write requests. In some embodiments, if there are no write requests in the queue 200, the write request from the host 150 may be written to the write buffer 112.
[0026] In some embodiments, all write requests may be added to queue 200 , and when write buffer 112 is no longer full, write requests from host 150 may be written to write buffer 112 .
[0027] At 350, a completion message (e.g., CQE) is returned to the host. In some embodiments, the host can release memory on the host device. For example, the host can save the write data, for example, in host memory, until it receives a CQE. Thus, the write data can be retrieved at any time when the host memory retains the data. In some embodiments, the host can release memory in the host data after the data is written to the write buffer 112.
[0028] At 360, the data is written from the write buffer to a storage medium (e.g., die 120). In some embodiments, writing the data to the storage medium may be a background process. In some embodiments, the write operation on the storage device may include adding error correction code (ECC) to the data, transferring the data and ECC to the NAND, programming the NAND, verifying the programming of the NAND, and any error handling at any of the above steps. It should be understood that the storage device does not need to perform all of the above steps, and may perform some or one of the above steps. For example, if the storage device does not have ECC, this step may not be performed.
[0029] In some embodiments, the write buffer may write a page of data to a storage medium (e.g., die 120). In some embodiments, the write buffer may write a word line (WL) or a super word line of data to a storage medium (e.g., die 120). For example, a WL may be 4 pages in a quad-level cell (QLC) SSD or 3 pages in a triple-level cell (TLC) SSD. In some embodiments, the size of the read may be a page and the size of the write may be a WL. It should be understood that the size of the write operation does not need to be a page or a WL and may be some other size determined by the storage device. For example, the storage device may write multiple WLs for each write operation. In some embodiments, a super block (SB) may be an EB from each plane of each die. For example, if the SSD has a Figure 1 As shown, with 16 dies, and each die having 4 planes, the storage device may have a total of 64 EBs. In some embodiments, a RU may be equal to an SB, a fraction of an SB, a multiple of an SB, or some other equivalent of an SB.
[0030] Although at 325, it is determined whether the write controller is full, this step need not occur in this order. For example, data may be sent to the FIFO queue 200 first (e.g., at 330). Then, the controller 110 may determine whether the write buffer 112 is full. If the write buffer 112 is not full, the controller 110 may obtain a write request from the queue 200 and write the data to the write buffer 112. In some embodiments, data received from the host (e.g., data from the SQE) may be written to the FIFO queue 200 continuously.
[0031] Figure 4 An example operating environment for a host device to send a write request to a storage device according to an example embodiment of the present disclosure is shown. Figure 4 The system includes a host 410 and a storage device 450. The host 410 may be Figure 1 The host 150 in the embodiment may be some other host. In addition, the storage device 450 may be Figure 1 The host 410 includes a submission queue 420. The submission queue 420 includes a first indicator (eg, SQ TDB 430) and a second indicator (eg, SQ HDB 440). The storage device 450 includes a write buffer queue 460. Figure 5 A flowchart of an example process for filling a storage medium according to an example embodiment of the present disclosure is shown. Figure 4 and Figure 5 Further description is given.
[0032] In some embodiments, at 510, an SQE is sent from a submission queue 420 on a host 410. For example, the host 410 may include a submission queue 420 for read and write requests to a storage device 450. In some embodiments, the host may use a first indicator (e.g., a submission queue tail doorbell (SQ TDB) 430) that indicates which request is stored in a write buffer queue 460 of the storage device 450. For example, when the host sends an SQE from the submission queue 420, the SQ TDB 430 may be updated to the next entry in the submission queue 420. Thus, the host 410 may send the next SQE from the submission queue 420, and the SQ TDB 430 may be updated again. This step may continue to occur until the submission queue 420 is empty or the SQ TDB 430 matches the SQ HDB 440, which will be described in further detail below. Figure 4 The write buffer queue 460 in may be Figure 2 The same queue as queue 200 in the host memory. In some embodiments, entries of write buffer queue 460 include an SQE and a pointer to data on the host (e.g., DB Val). Thus, each entry on write buffer queue 460 may correspond to an entry in commit queue 420 and a pointer to its associated data in host memory. In some embodiments, the storage device may retrieve an SQE from host 410.
[0033] At 520, the SQE is received by the storage device 450. In some embodiments, the SQE may be placed in the write buffer queue 460. It should be understood that the data associated with the write command in the SQE does not need to be placed in the queue, and if the write buffer has space for the data from the SQE, the data may be placed in the write buffer. In addition, in some embodiments, the SQE may be a read request processed by the controller and may not compete for write buffer space or be written to the queue. In some embodiments, the controller may write the SQE to the write buffer queue. In some embodiments, by writing data to the queue, the host 410 may continue to add SQEs to the submission queue 420 instead of waiting for data to be written (e.g., receiving a CQE). Since the indicator (e.g., SQ TDB 430) indicates what data has been written to the write buffer queue 460, the write buffer queue 460 may continue to receive SQEs until it runs out of space or other criteria have been met.
[0034] At 530, the controller determines whether the write buffer 532 is full. For example, if the SQE is a write request, the controller can determine which write buffer to write data to corresponding to the RG and RUH of the SQE. If the write buffer 532 is above the threshold, the write request can be retained in the write buffer queue 460. If the write buffer 532 is below the threshold, the write buffer 532 can be filled with data from the host 410 associated with the command extracted from the write buffer queue 460.
[0035] At 540, the controller retrieves data from the host 410 based on the write request from the queue. For example, the SQE may indicate what data is to be sent from the host to the storage device. In some embodiments, a second indicator (e.g., a Submit Queue Header Bell (SQ HDB) 440) may be used to indicate which commands have begun to be processed by the storage device 450 (e.g., data has been retrieved from the host). In some embodiments, by using an indicator of the SQE indicating which data has been written to the write buffer (e.g., SQ HDB 440) and which SQEs have been received by the write buffer queue (e.g., SQ TDB 430), the host 410 may know which data can be read and whether to continue submitting new SQEs to the storage device 450 (e.g., using CQEs from the storage device 450). In some embodiments, the storage device 450 may have a completion queue (not shown). In some embodiments, when data has been written to the write buffer, the storage device 450 may insert a CQE into the completion queue, and the CQE may be passed to the host 410. SQ HDB 440 may be moved to a new entry on the queue, indicating that the data has been written to the write buffer. In some embodiments, moving SQ HDB 440 may allow the host to remove data from the host (e.g., host memory). For example, until the data has been written to storage device 450, a copy of the data may need to reside on host 410. Once it has been written, the host may no longer need to maintain the copy and may be removed.
[0036] In some embodiments, the write command may be long (e.g., the data to be transferred to the storage device 450 may be large). In some embodiments, the data 534 may be transferred in segments. In some embodiments, the write buffer 532 may be managed in segments. In some embodiments, the write buffer 532 may be marked for programming. For example, the write buffer 532 may be marked as ready for programming, and RU information may be provided to program the data into the correct RU.
[0037] At 550, the data is written to the storage medium. The data need not be written immediately after the data is written to the write buffer and may be written at any time. For example, the controller may determine when the write buffer has enough data to write to the WL of the storage medium and write to the storage medium.
[0038] In some embodiments, the write buffer queue 460 can determine whether there is data to be written to a particular RU in the write buffer 532. In some embodiments, the storage device 450 can determine whether the storage medium (e.g., NAND die) is available for activity. In some embodiments, the storage device can wait for other programs or reads to complete. For example, if a RU is available but other locations on the NAND are busy, the storage device 450 can wait for these operations to complete before writing to the storage medium.
[0039] In some embodiments, the storage device can continue to obtain and resolve non-conflicting SQEs. For example, if a particular write buffer is full, the storage device can still process read requests and request other write buffers. In some embodiments, when a request is removed from the queue, an indicator of the submission queue indicating which data has been written can be updated. In some embodiments, a single write buffer can be used, and the write buffer can be partitioned. The partitioning can be by RG, RUH, RG / RUH combination or other options. In some embodiments, the partitions can be static. In some embodiments, the partitions can be shared (for example, if one or more partitions are temporarily unavailable, the write buffer can use an overflow shared pool).
[0040] In some embodiments, if the queue is full and the most recent fetch meets the criteria for insertion into the queue, the indicator of which requests the queue has received may not continue.
[0041] In some embodiments, the threshold can be set to any of the following options: percentage of buffer space, number of logical blocks (NLB), or amount of data to be programmed on the NAND. In some embodiments, the threshold can be set to any value that can be used by the controller to determine whether to write data to the buffer or write a request to the queue.
[0042] In some embodiments, for each queue, the outstanding NLBs may be counted. In some embodiments, the commands may be parsed and the write buffer may be consumed once it has enough data to fill one programming unit of a RU.
[0043] In some embodiments, the size of a RU may be several EBs, and an EB may have many WLs. In some embodiments, the storage device may store enough content in a write buffer to program one WL for each EB in the RU. The storage device may then write data from the write buffer (e.g., program the portion of the data from the write buffer).
[0044] In some embodiments, the storage device may write one WL from each EB in the die to the write buffer. Then, in some embodiments, the storage device may have so much data on one die that the one die is occupied by programming. In this example, the RUs may be striped across all 16 dies. In some embodiments, the RUs may be programmed at a time (1WL*4) and this may occur 16 times until the process returns to the first die. In some embodiments, the storage device may program the next WL down on the EB of that die.
[0045] In some embodiments, the write buffer may be determined to be empty after data is successfully transferred to the storage medium, after programming is successful, or after an XOR or other data protection is generated on the incoming data.
[0046] In some embodiments, there may be one queue per partition, where there is a partition per RUH, per RG, or per RG / RUH combination. In some embodiments, there may be more than one queue per partition. For example, two different hosts may each have a queue for sending write requests to the same buffer. Additionally, in some embodiments, there may be one queue for more than one partition.
[0047] In some embodiments, the write buffer may be managed according to the following options: a fully allocated buffer without any partitions; a hard partition per partition; some free pool reserved per partition and used for overflow; and / or a dynamic allocation set as a function of multi-tenant sharing of SSD requests, which may vary as a function of tenant write amplification or tenant performance. In some embodiments, an optional timer may be incorporated as follows. For example, a timer may be associated with a command in a FIFO and may fetch the command into the write buffer to avoid host command timeouts.
[0048] In some embodiments, the SSD may include an internal FIFO for each RG and / or RUH for write commands. In some embodiments, the FIFO may be used to store conflicting write SQEs with various write buffer sharing options as described herein. In some embodiments, NLBs may be counted in the FIFO to read a complete word line (WL) program into the NAND.
[0049] The principles disclosed herein have independent utility and can be embodied separately, and not every embodiment can utilize every principle. However, these principles can also be embodied in various combinations, some of which can amplify the benefits of each principle in a synergistic manner.
[0050] For the purpose of illustrating the inventive principles of the present disclosure, some example embodiments may be described in the context of specific implementation details, such as a processing system that may implement a NUMA architecture, a memory device, and / or a pool that may be connected to a processing system using an interconnect interface and / or a protocol Compute Express Link (CXL), etc. However, the principles are not limited to these example details and may be implemented using any other type of system architecture, interface, protocol, etc.
[0051] Although some example embodiments may be described in the context of specific implementation details, such as a processing system that may implement a NUMA architecture, memory devices and / or pools that may be connected to the processing system using an interconnect interface and / or protocol CXL, etc., the principles are not limited to these example details and may be implemented using any other type of system architecture, interface, protocol, etc. For example, in some embodiments, one or more memory devices may be connected using any type of interface and / or protocol, including Peripheral Component Interconnect Express (PCIe), Non-Volatile Memory Express (NVMe), NVMe over Fabric (NVMe oF), Advanced Extensible Interface (AXI), Ultra Path Interconnect (UPI), Ethernet, Transmission Control Protocol / Internet Protocol (TCP / IP), Remote Direct Memory Access (RDMA), RDMA over Converged Ethernet (ROCE), Fibre Channel, InfiniBand, Serial ATA (SATA), Small Computer System Interface (SCSI), Serial Attached SCSI (SAS), iWARP, etc., or any combination thereof. In some embodiments, the interconnect interface may be implemented using one or more memory semantics and / or memory consistency interfaces and / or protocols, including one or more CXL protocols (such as CXL.mem, CXL.io, and / or CXL.cache), Gen-Z, a consistent accelerator processor interface (CAPI), a cache coherent interconnect for accelerators (CCIX), etc., or any combination thereof. Any memory device may be implemented with one or more of any type of memory device interface, including DDR, DDR2, DDR3, DDR4, DDR5, LPDDRX, an open memory interface (OMI), NVLink, high bandwidth memory (HBM), HBM2, HBM3, etc.
[0052] In some embodiments, any of the memory devices, memory pools, hosts, etc., or components thereof may be implemented in any physical and / or electrical configuration and / or form factor, such as a stand-alone device, an add-on card such as a PCIe adapter or expansion card, a plug-in device that can be inserted into a connector and / or slot of a server chassis (e.g., a connector on a backplane and / or midplane of a server or other device), etc. In some embodiments, any memory device, memory pool, host, etc., or components thereof may be implemented using any connector configuration for an interconnect interface (such as a SATA connector, a SCSI connector, a SAS connector, an M.2 connector, a U.2 connector, a U.3 connector, etc.), in a form factor for a storage device (such as 3.5 inches, 2.5 inches, 1.8 inches, M.2, Enterprise and Data Center SSD Form Factor (EDSFF), NF1, etc.). Any device disclosed herein may be implemented and / or used in conjunction with, in whole or in part, a server chassis, a server rack, a data center, a data center, an edge data center, a mobile edge data center, and / or any combination thereof. In some embodiments, any of the memory devices, memory pools, hosts, etc., or components thereof, may be implemented as CXL Type 1 devices, CXL Type 2 devices, CXL Type 3 devices, etc.
[0053] In some embodiments, any functionality described herein, including, for example, any logic for implementing tiering, device selection, etc., may be implemented in hardware, software, or a combination thereof, including combinatorial logic, sequential logic, one or more timers, counters, registers, and / or state machines, one or more complex programmable logic devices (CPLDs), field programmable gate arrays (FPGAs), application specific integrated circuits (ASICs), central processing units (CPUs), such as complex instruction set computer (CISC) processors (such as x86 processors) and / or reduced instruction set computer (RISC) processors (such as ARM processors), graphics processing units (GPUs), neural processing units (NPUs), tensor processing units (TPUs), etc., which execute instructions stored in any type of memory, or any combination thereof. In some embodiments, one or more components may be implemented as a system on a chip (SOC).
[0054] In the present disclosure, many specific details are set forth in order to provide a thorough understanding of the present disclosure, but the disclosed aspects can be practiced without these specific details. In other instances, well-known methods, processes, components, and circuits are not described in detail to avoid obscuring the subject matter disclosed herein.
[0055] References to "one embodiment" or "an embodiment" throughout the specification mean that the specific features, structures, or characteristics described in conjunction with the embodiment may be included in at least one embodiment disclosed herein. Therefore, the phrases "in one embodiment" or "in an embodiment" or "according to an embodiment" (or other phrases with similar meanings) that appear throughout this specification may not necessarily all refer to the same embodiment. In addition, the specific features, structures, or characteristics may be combined in any suitable manner in one or more embodiments. In this regard, as used herein, the word "exemplary" means "used as an example, instance, or illustration". Any embodiment described herein as "exemplary" should not be interpreted as necessarily being preferred or advantageous over other embodiments. In addition, the specific features, structures, or characteristics may be combined in any suitable manner in one or more embodiments. In addition, depending on the context discussed herein, a singular term may include a corresponding plural form, and a plural term may include a corresponding singular form. Similarly, hyphenated terms (e.g., "two-dimensional", "pre-determined", "pixel-specific", etc.) may occasionally be used interchangeably with corresponding non-hyphenated versions (e.g., "two dimensional", "predetermined", "pixel-specific", etc.), and capitalized terms (e.g., "Counter Clock", "Row Select", "PIXOUT", etc.) may be used interchangeably with corresponding non-capitalized versions (e.g., "counter clock", "row select", "pixout", etc.). Such occasional interchangeable usage should not be considered inconsistent with each other.
[0056] In addition, depending on the context discussed herein, singular terms may include corresponding plural forms, and plural terms may include corresponding singular forms. It should also be noted that the various drawings (including component drawings) shown and discussed herein are for illustrative purposes only and are not drawn to scale. For example, for clarity, the size of some elements may be enlarged relative to other elements. In addition, if deemed appropriate, reference numerals are repeated in the drawings to indicate corresponding and / or similar elements.
[0057] The terms used herein are only used for the purpose of describing some example embodiments and are not intended to limit the claimed subject matter. As used herein, the singular forms "a", "an", and "the" are intended to also include the plural forms, unless the context clearly indicates otherwise. When used in this specification, the terms "include" and / or "comprise" specify the presence of the features, integers, steps, operations, elements, and / or components, but do not exclude the presence or addition of one or more other features, integers, steps, operations, elements, components, and / or groups thereof.
[0058] When an element or layer is referred to as being on, "connected to," or "coupled to" another element or layer, it may be directly on, connected to, or coupled to another element or layer, or there may be intermediate elements or layers. In contrast, when an element is referred to as being "directly on," "directly connected to," or "directly coupled to" another element or layer, there are no intermediate elements or layers. The same reference numerals always refer to the same elements. As used herein, the term "and / or" may include any and all combinations of one or more associated listed items.
[0059] As used herein, the terms "first", "second", etc. are used as labels for the nouns that precede them and do not imply any type of ordering (e.g., spatial, temporal, logical, etc.) unless explicitly defined as such. In addition, the same figure mark may be used in two or more figures to refer to parts, components, blocks, circuits, units, or modules with the same or similar functions. However, such use is only for simplicity of illustration and ease of discussion; it does not mean that the construction or architectural details of such components or units are the same in all embodiments, or that such commonly referenced parts / modules are the only way to implement some example embodiments disclosed herein.
[0060] The term "module" may refer to any combination of software, firmware, and / or hardware configured to provide the functions described herein in conjunction with the module. For example, software may be embodied as a software package, code, and / or instruction set or instructions, and the term "hardware" as used in any embodiment described herein may include, for example, components, hardwired circuits, programmable circuits, state machine circuits, and / or firmware storing instructions executed by programmable circuits, either alone or in any combination. Modules may be embodied collectively or individually as circuits forming part of a larger system, such as, but not limited to, integrated circuits (ICs), systems on chips (SoCs), components, and the like. The embodiments of the subject matter and operations described in this specification may be implemented in digital electronic circuits, or in computer software, firmware, or hardware, including the structures disclosed in this specification and their structural equivalents, or a combination of one or more of them. The embodiments of the subject matter described in this specification may be implemented as one or more computer programs, for example, one or more modules of computer program instructions, which are encoded on a computer storage medium for execution by a data processing device or for controlling the operation of a data processing device. Alternatively or additionally, program instructions may be encoded on an artificially generated propagation signal, for example, a machine-generated electrical, optical or electromagnetic signal, which is generated to encode information for transmission to a suitable receiver device for execution by a data processing device. A computer storage medium may be a computer-readable storage device, a computer-readable storage substrate, a random or serial access memory array or device, or a combination thereof, or be included therein. In addition, although a computer storage medium is not a propagation signal, a computer storage medium may be a source or destination of computer program instructions encoded in an artificially generated propagation signal. A computer storage medium may also be one or more separate physical components or media (e.g., multiple CDs, disks, or other storage devices), or be included in one or more separate physical components or media (e.g., multiple CDs, disks, or other storage devices). In addition, the operations described in this specification may be implemented as operations performed by a data processing device on data stored on one or more computer-readable storage devices or received from other sources.
[0061] Although this specification may contain many specific implementation details, the implementation details should not be interpreted as limiting the scope of any claimed subject matter, but rather as a description of features specific to a particular embodiment. Certain features described in the context of separate embodiments in this specification may also be implemented in combination in a single embodiment. Conversely, the various features described in the context of a single embodiment may also be implemented in multiple embodiments individually or in any suitable sub-combination. In addition, although features may be described above as functioning in certain combinations and even initially claimed as such, one or more features from the claimed combination may be cut out of the combination in some cases, and the claimed combination may be directed to a sub-combination or a variation of the sub-combination.
[0062] Similarly, although operations are depicted in a particular order in the accompanying drawings, this should not be understood as requiring that the operations be performed in the particular order shown or in sequence, or that all of the operations shown be performed, to achieve the desired results. In some cases, multitasking and parallel processing may be advantageous. In addition, the separation of various system components in the above-described embodiments should not be understood as requiring such separation in all embodiments, and it should be understood that the described program components and systems can generally be integrated together in a single software product or packaged into multiple software products.
[0063] Thus, specific embodiments of the subject matter have been described herein. Other embodiments are within the scope of the appended claims. In some cases, the actions set forth in the claims can be performed in a different order and still achieve the desired results. In addition, the processes depicted in the accompanying drawings do not necessarily require the specific order or sequential order shown to achieve the desired results. In some embodiments, multitasking and parallel processing may be advantageous.
[0064] Although certain exemplary embodiments have been described and shown in the accompanying drawings, it should be understood that these embodiments are merely illustrative, and the scope of the present disclosure is not limited to the embodiments described or shown herein. The present invention may be modified in arrangement and detail without departing from the concept of the present invention, and these changes and modifications are considered to fall within the scope of the appended claims.
Claims
1. A method, include: receiving a first request from a host device to write first data to a memory device; adding the first request to a queue on the memory device; determining availability of a write buffer of the memory device; retrieving the first data from the host device based on the determination and the first request added to the queue; as well as The first data is written to a write buffer of the memory device.
2. The method according to claim 1, further comprising: include: returning a completion message to the host device based on writing the first data to the write buffer; as well as The first data is written from a write buffer of the memory device to a storage medium.
3. The method according to claim 1, in, The first request is a submission queue entry SQE, and wherein the method further comprises: parsing the SQE; and It is determined that the SQE is a write request.
4. The method according to claim 1, in, The first request is a submission queue entry SQE, and wherein the method further comprises: Parsing a recycle group RG and a recycle unit handle RUH from the SQE; and Wherein, adding the first request to a queue includes queuing the SQE in a first-in-first-out (FIFO) queue, wherein the FIFO queue corresponds to the RG and the RUH.
5. The method according to claim 1, in, Adding the first request to the queue comprises: determining that the size of the data in the write buffer is above a threshold; and The first data is added to the queue.
6. The method according to claim 1, in, Determining the availability of the write buffer includes determining that a size of data in the write buffer is below a threshold; and writing the first data to the write buffer includes: writing the first data from the queue to the write buffer; and The first data is removed from the queue.
7. The method according to claim 1, in, The queue includes a first indicator, wherein the first indicator corresponds to a location in a host memory of the host device, wherein the location in the host memory corresponds to the first data.
8. The method according to claim 1, further comprising: include: receiving, from the host device, a second request to read second data from the memory device; as well as The second data is retrieved from the memory device; wherein the write buffer is above a threshold.
9. The method according to claim 1, further comprising: include: receiving, from the host device, a second request to write second data to the memory device; as well as The second request is added to the queue on the memory device.
10. The method of claim 1, further comprising a second indicator, in, The second indicator corresponds to the most recent first request.
11. A device, include: a controller, wherein the controller includes a write buffer; storage media; and queue; wherein the controller performs an operation, the operation comprising: receiving a first request from a host device to write first data to the storage medium; adding the first request to the queue, wherein the queue is a FIFO queue; determining availability of the write buffer; retrieving the first data from the host device based on the determination and the first request added to the queue; Writing the first data into the write buffer; returning a completion message to the host device; and The first data is written from the write buffer to the storage medium.
12. The device according to claim 11, in, The first request is a submission queue entry (SQE), the completion message is a completion queue entry, and wherein the controller further performs operations, the operations comprising: parsing the SQE; and It is determined that the SQE is a write command.
13. The device according to claim 11, in, The first request is a submission queue entry (SQE), and wherein the controller further performs operations including: A recycle group RG and a recycle unit handle RUH are parsed from the SQE; wherein the queue corresponds to the RG and the RUH.
14. The device according to claim 11, in, Adding the first request to the queue comprises: determining that the size of the data in the write buffer is above a threshold; and The first data is added to the queue.
15. The device according to claim 11, in, Determining the availability of the write buffer includes determining that a size of data in the write buffer is below a threshold; and writing the first data to the write buffer includes: writing the first data from the queue to the write buffer; and The first data is removed from the queue.
16. The device according to claim 11, in, The controller performs an operation, the operation comprising: receiving, from the host device, a second request to write second data to the storage medium; adding the second request to the queue, And wherein, writing the first data into the write buffer comprises: Determining that the size of the data in the write buffer is below a threshold; writing the first data from the queue to the write buffer; and The second data is written from the queue to the write buffer.
17. The device according to claim 11, in, The queue includes a first indicator, wherein the first indicator corresponds to a location in a host memory of the host device, wherein the location in the host memory corresponds to the first data.
18. A system, include: Host device; and A storage device, wherein the storage device comprises: a controller, wherein the controller includes a write buffer; storage media; and queue; wherein the controller performs an operation, the operation comprising: receiving a first request from the host device to write first data to the storage medium; adding the first request to the queue, wherein the queue is a FIFO queue; determining availability of the write buffer; retrieving the first data from the host device based on the determination and the first request added to the queue; Writing the first data into the write buffer; returning a completion message to the host device; and The first data is written from the write buffer to the storage medium.
19. The system according to claim 18, in, Adding the first request to the queue comprises: determining that the size of the data in the write buffer is above a threshold; and The first data is added to the queue.
20. The system according to claim 18, in, Determining the availability of the write buffer includes determining that a size of data in the write buffer is below a threshold; and writing the first data to the write buffer includes: writing the first data from the queue to the write buffer; and The first data is removed from the queue.
Citation Information
Cited By
Data writing control method and system, terminal and medium
CN119311229A
