Maintaining queues for the memory subsystem
By using prioritized memory die queues with threshold management, the memory subsystem ensures efficient command execution, prioritizing higher priority operations and reducing resource wastage in memory subsystem access operations.
Patent Information
- Application Number
- JP2022554441
- Authority / Receiving Office
- JP · JP
- Patent Type
- Patents
- Current Assignee / Owner
- Filing Date
- 2020-03-10
- Publication Date
- 2024-11-08
- Estimated Expiration
- 2040-03-10
AI Technical Summary
Conventional memory subsystem access operations fail to effectively prioritize commands, leading to unnecessary allocation of system resources to lower priority operations, preventing higher priority commands from being issued when needed.
Implementing memory die queues with prioritized subqueues for each die, where commands are assigned based on priority levels and a threshold mechanism to manage command loads, ensuring higher priority commands are issued before lower priority ones and preventing queue overflow.
This approach reduces unnecessary resource consumption by prioritizing commands efficiently, allowing higher priority operations to be executed promptly and conserving system resources.
Smart Images

Figure 0007579875000001 
Figure 0007579875000002 
Figure 0007579875000003
Abstract
Description
[Technical field]
[0001] [Cross Reference] This patent application is a national stage application of International Patent Application No. PCT / CN2020 / 078605, entitled “MAINTAINING QUEUES FOR MEMORY SUB-SYSTEMS,” filed on March 10, 2020, by WU et al., which is assigned to the assignee of the present application and is expressly incorporated by reference in its entirety herein.
[0002] The following relates generally to memory subsystems, and more specifically to maintaining queues for memory subsystems. [Background technology]
[0003] A memory subsystem may include one or more memory devices for storing data. The memory devices may be, for example, non-volatile and volatile memory devices. In general, a host system may utilize a memory subsystem to store data in and retrieve data from the memory devices. [Brief description of the drawings]
[0004] The disclosure will be more fully understood from the detailed description given below and from the accompanying drawings of various examples of the disclosure, which should not, however, be construed as limiting the disclosure to specific examples, but are for illustration and understanding only.
[0005] [Figure 1] An exemplary computing system including a memory subsystem in accordance with some examples of the present disclosure is described. [Diagram 2] FIG. 1 is a flow diagram of an example method for maintaining a queue for a memory subsystem in accordance with some examples of the present disclosure. [Figure 3A] 1 is an example of a firmware queue for a memory subsystem according to some examples of the present disclosure. [Figure 3B] 1 is an example of a global pool for a memory controller according to some examples of the present disclosure. [Figure 4] 1 is an example of a memory subsystem for maintaining queues in accordance with certain examples of the present disclosure. [Diagram 5]FIG. 1 is a block diagram of an exemplary computer system in which examples of the present disclosure may operate. DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS
[0006] Aspects of the present disclosure are directed to maintaining queues in a memory subsystem. The memory subsystem may be a storage device, a memory module, or a hybrid of a storage device and a memory module. Examples of storage devices and memory modules are described herein with respect to FIG. 1. In general, a host system may utilize a memory subsystem that includes one or more components, such as a memory device, that store data. The host system may provide data to be stored in the memory subsystem and may request data to be retrieved from the memory subsystem.
[0007] The memory device may be a non-volatile memory device. One example of a non-volatile memory device is a not-and-connect (NAND) memory device. Other examples of non-volatile memory devices are described below in relation to FIG. 1. A non-volatile memory device is a package of one or more dies. Each die may be composed of one or more planes. The planes may be grouped into logical units (LUNs). For some types of non-volatile memory devices (e.g., NAND devices), each plane is composed of a set of physical blocks. Each block is composed of a set of pages. Each page is composed of a set of memory cells ("cells"). A cell is an electronic circuit that stores information. A data block hereinafter refers to a unit of a memory device used to store data and may include a group of memory cells, a group of word lines, a word line, or an individual memory cell.
[0008] A data operation may be performed by the memory subsystem. A data operation may be a host-initiated operation. For example, a host system may initiate a data operation (e.g., write, read, erase, etc.) on the memory subsystem. The host system may send access requests (e.g., write commands, read commands) to the memory subsystem, such as to store data on a memory device in the memory subsystem and to read data from a memory device in the memory subsystem.
[0009] In a conventional access operation of a NAND cell, commands may be constantly sent to various memory dies. The commands may be associated with different access operations (e.g., read operations, write operations, etc.) having various levels of priority. That is, it may be desirable for a host read command to be sent to a particular memory die before a read command or a write command is sent to the same die. However, because a memory subsystem may include many dies, and each die may be associated with a large number of commands and command types, a conventional access operation may not be able to effectively prioritize the sending of commands. Also, because a conventional access operation may not be able to effectively prioritize the sending of commands, a lower priority command may be issued before a higher priority command, unnecessarily utilizing system resources (e.g., power). Thus, a conventional access operation may result in system resources being allocated to relatively low priority operations, preventing the memory subsystem from being able to issue a higher priority command when needed.
[0010] Aspects of the present disclosure address these and other deficiencies by maintaining queues for a memory subsystem at the die level. For example, each memory die of a memory subsystem may be associated with a queue (e.g., a memory die queue) to maintain commands associated with the individual die. Additionally, each memory die queue may include multiple sub-queues (e.g., priority queues) to maintain commands associated with particular priority levels. Commands may be issued based on a priority level associated with an individual priority queue and based on the amount of commands in the individual queue. That is, if the number of commands in a queue exceeds a threshold, a command may be issued before any additional commands are assigned to the queue. Thus, commands may be issued based on both the priority level associated with the command and the number of commands in the queue. In some examples, commands may be issued by a local memory controller.
[0011] For example, a memory die queue associated with a particular memory die of a memory subsystem may include one or more (e.g., two, three, six) priority queues. Each priority queue may be associated with (e.g., reserved for) commands associated with a particular priority level. If three priority queues are used, illustratively, a first priority queue may be associated with commands having a first (e.g., highest, most urgent) priority level, a second priority queue may be associated with commands having a second (e.g., medium, intermediate) priority level, and a third priority queue may be associated with commands having a third (e.g., lowest, least urgent) priority level. When a command for a memory die is received, it may be assigned to a priority queue based on its associated priority level, which may be predefined. Thus, a command in a higher priority queue may be issued before a command in a lower priority queue, i.e., a command in a first priority queue may be issued before a command in a second priority queue. If a higher priority command is being issued, the command may still be assigned to a lower priority queue. However, if the amount of commands in a queue exceeds a threshold, the commands in the queue (e.g., all commands in the queue) may be issued regardless of the priority level associated with the queue. Once the commands have been issued, issuance of commands in other (e.g., higher priority) queues may resume. Such techniques may be implemented on a per-die or system level, both of which may reduce system resources (e.g., power) that would otherwise be required to issue a large number of commands in a single queue.
[0012] figure 1 1 illustrates an example of a computing system 100 including a memory subsystem 110 according to some embodiments of the present disclosure. The memory subsystem 110 may include media such as one or more non-volatile memory devices (e.g., memory device 130), one or more volatile memory devices (e.g., memory device 140), or a combination thereof.
[0013] The memory subsystem 110 can be a storage device, a memory module, or a hybrid of a storage device and a memory module. Examples of storage devices include solid-state drives (SSDs), flash drives, universal serial bus (USB) flash drives, embedded multimedia controller (eMMC) drives, universal flash storage (UFS) drives, secure digital (SD) cards, and hard disk drives (HDDs). Examples of memory modules include dual in-line memory modules (DIMMs), small outline DIMMs (SO-DIMMs), and various types of non-volatile DIMMs (NVDIMMs).
[0014] Computing system 100 may be a computing device such as a desktop computer, a laptop computer, a network server, a mobile device, a vehicle (e.g., an aircraft, drone, train, automobile, or other vehicle), an Internet of Things (IoT) enabled device, an embedded computer (e.g., contained within a vehicle, industrial equipment, or networked commercial device), or any such computing device that includes memory and processing devices.
[0015] A computing system 100 may include a host system 105 coupled to one or more memory systems 110. In some examples, the host system 105 is coupled to different types of memory systems 110. Figure 1 illustrates an example of a host system 105 coupled to one memory subsystem 110. As used herein, "coupled" or "coupled with" generally refers to a connection between components, which may be an indirect communication connection or a direct communication connection (e.g., without an intervening component), whether wired or wireless, including electrical, optical, magnetic, etc. connections.
[0016] The host system 105 may include a processor chipset and a software stack executed by the processor chipset. The processor chipset may include one or more cores, one or more caches, a memory controller (e.g., an NVDIMM controller), and a storage protocol controller (e.g., a PCIe controller, a SATA controller). The host system 105 uses the memory subsystem 110, for example, to write data to the memory subsystem 110 and read data from the memory subsystem 110.
[0017] The host system 105 may be coupled to the memory subsystem 110 using a physical host interface. Examples of the physical host interface include, but are not limited to, a Serial Advanced Technology Attachment (SATA) interface, a Peripheral Component Interconnect Express (PCIe) interface, a USB interface, a Fibre Channel, a Small Computer System Interface (SCSI), a Serial Attached SCSI (SAS), a Double Data Rate (DDR) memory bus, a Dual In-Line Memory Module (DIMM) interface (e.g., a DIMM socket interface supporting Double Data Rate (DDR)), an Open NAND Flash Interface (ONFI), Double Data Rate (DDR), Low Power Double Data Rate (LPDDR), or any other interface. The physical host interface may be used to transmit data between the host system 105 and the memory subsystem 110. The host system 105 may further utilize a Non-Volatile Memory Express (NVMe) interface to access components (e.g., memory device 130) when the memory subsystem 110 is coupled to the host system 105 by a PCIe interface. The physical host interface may provide an interface for passing control, address, data, and other signals between memory subsystem 110 and host system 105. Figure 1 illustrates memory subsystem 110 as an example. In general, host system 105 may access multiple memory subsystems via the same communication connection, multiple separate communication connections, and / or a combination of communication connections.
[0018] Memory devices 130, 140 may include any combination of different types of non-volatile and / or volatile memory devices. The volatile memory devices (e.g., memory device 140) may be random access memories (RAMs), such as, but not limited to, dynamic RAMs (DRAMs) and synchronous DRAMs (SDRAMs).
[0019] Some examples of non-volatile memory devices (e.g., memory device 130) include write-in-place memories such as negative-and-conjunction (NAND) type flash memories and three-dimensional cross-point ("3D cross-point") memories, which are cross-point arrays of non-volatile memory cells. Cross-point arrays of non-volatile memories can perform bit storage based on changes in bulk resistance in combination with stackable cross-grid data access arrays. Also, in contrast to many flash-based memories, cross-point non-volatile memories can perform write-in-place operations, in which the non-volatile memory cells can be programmed without the non-volatile memory cells being previously erased. NAND type flash memories include, for example, two-dimensional NAND (2D NAND) and three-dimensional NAND (3D NAND).
[0020] Each of the memory devices 130 may include one or more arrays of memory cells. Some types of memory cells, such as single level cells (SLC), may store one bit per cell. Other types of memory cells, such as multi-level cells (MLC), triple level cells (TLC), quad level cells (QLC), and penta level cells (PLC), may store multiple bits per cell. In some embodiments, each of the memory devices 130 may include one or more arrays of memory cells, such as SLC, MLC, TLC, QLC, or any combination thereof. In some embodiments, a particular memory device may include an SLC portion of memory cells, as well as an MLC portion, a TLC portion, a QLC portion, or a PLC portion. The memory cells of the memory devices 130 may be grouped as pages, which may refer to logical units of a memory device used to store data. In some types of memory (e.g., NAND), pages may be grouped to form blocks.
[0021] Although non-volatile memory components such as NAND type flash memory (e.g., 2D NAND, 3D NAND) and 3D cross-point arrays of non-volatile memory cells are described, the memory device 130 may be based on any other type of non-volatile memory, such as ROM, phase change memory (PCM), self-selection memory, other chalcogenide-based memories, ferroelectric transistor random access memory (FeTRAM), ferroelectric RAM (FeRAM), magnetic RAM (MRAM), spin-transfer torque (STT)-MRAM, conductive bridging RAM (CBRAM), resistive random access memory (RRAM), oxide-based RRAM (OxRAM), negative or (NOR) flash memory, and electrically erasable programmable ROM (EEPROM).
[0022] Memory subsystem controller 115 (or controller 115 for simplicity) may communicate with memory device 130 to perform operations such as reading data, writing data, or erasing data in memory device 130 and other such operations. Memory subsystem controller 115 may include hardware such as one or more integrated circuits and / or discrete components, buffer memory, or a combination thereof. Memory subsystem controller 115 may be a microcontroller, a special purpose logic circuit (e.g., a field programmable gate array (FPGA), an application specific integrated circuit (ASIC), a digital signal processor (DSP)), or another suitable processor.
[0023] The memory subsystem controller 115 may include a processor 120 (e.g., a processing device) configured to execute instructions stored in a local memory 125. In the illustrated example, the local memory 125 of the memory subsystem controller 115 includes an embedded memory configured to store instructions for implementing various processes, operations, logic flows, and routines that control the operation of the memory subsystem 110, including handling communications between the memory subsystem 110 and the host system 105.
[0024] In some examples, local memory 125 may include memory registers that store memory pointers, fetched data, etc. Local memory 125 may also include ROM for storing microcode. Although the example memory subsystem 110 of FIG. 1 is described as including a memory subsystem controller 115, in other examples of the present disclosure, memory subsystem 110 may not include a memory subsystem controller 115 and instead rely on external control (e.g., provided by an external host or by a processor or controller separate from the memory subsystem).
[0025] In general, the memory subsystem controller 115 may receive commands or operations from the host system 105 and may translate the commands or operations into instructions or appropriate commands to achieve the desired access to the memory devices 130 and / or 140. The memory subsystem controller 115 may be responsible for other operations such as wear leveling operations, garbage collection procedures, error detection and error correction code (ECC) operations, encryption operations, caching operations, and address translation between logical addresses (e.g., logical block addresses (LBA), namespace) and physical addresses (e.g., physical block addresses) associated with the memory devices 130. The memory subsystem controller 115 may further include a host interface circuit to communicate with the host system 105 via a physical host interface. The host interface circuit may translate commands received from the host system into command instructions for accessing the memory devices 130 and / or 140, and may translate responses associated with the memory devices 130 and / or 140 into information for the host system 105.
[0026] Memory subsystem 110 may also include additional circuits or components not described. In some examples, memory subsystem 110 may include a cache or buffer (e.g., DRAM) and address circuitry (e.g., row and column decoders) that may receive addresses from memory subsystem controller 115 and decode the addresses to access memory device 130.
[0027] In some examples, memory device 130 includes a local media controller 135 that operates with memory subsystem controller 115 to perform operations on one or more memory cells of memory device 130. An external controller (e.g., memory subsystem controller 115) may externally manage memory device 130 (e.g., perform media management operations on memory device 130). In some embodiments, memory device 130 is a managed memory device, which is a raw memory device combined with a local controller (e.g., local controller 135) for media management within the same memory device package. One example of a managed memory device is a managed NAND (MNAND) device.
[0028] Memory subsystem 110 includes a queue manager 150 that manages commands according to an associated priority level and number of commands associated with a particular queue. For example, each memory die (e.g., memory device 130, memory device 140) of memory subsystem 110 may be associated with a memory die queue. The memory die queues may each include one or more priority queues to which commands (e.g., read commands, write commands, host read commands, etc.) are assigned for issuance. When a command associated with a particular die is received, queue manager 150 may determine a priority level associated with the command (i.e., queue manager 150 may determine the type of command) and assign the command to a priority queue associated with the die. Commands may be issued from individual priority queues based on the associated priority level. Thus, commands associated with queues having higher priority levels may be issued before commands associated with queues having relatively lower priority levels. In some instances, however, lower priority commands may accumulate in individual queues while higher priority commands are being issued. Queue manager 150 may manage (e.g., track) the amount of commands contained in any one queue and may issue commands (e.g., all of the commands in a queue) if the amount exceeds a threshold. Once the commands have been issued, queue manager 150 may resume issuing commands based on their associated priority levels.
[0029] The amount of commands in any one queue may be managed at a per-die level (e.g., the number of commands in a priority queue associated with a single die) or globally (e.g., based on the number of active dies in the subsystem). In either example, preventing a queue from accumulating a threshold amount of commands may reduce system resources (e.g., power) that might otherwise be utilized to issue commands in the queue.
[0030] In some examples, memory subsystem controller 115 includes at least a portion of queue manager 150. For example, memory subsystem controller 115 may include processor 120 (e.g., a processing device) configured to execute instructions stored in local memory 125 to perform the operations described herein. In some examples, queue manager 150 is part of host system 105, an application, or an operating system.
[0031] 2 is a flow diagram of an example method 200 for maintaining a queue for a memory subsystem according to some examples of the present disclosure. The method 200 may be performed by processing logic, which may include hardware (e.g., a processing device, circuitry, dedicated logic, programmable logic, microcode, device hardware, integrated circuits, etc.), software (e.g., instructions executed or executed on a processing device), or a combination thereof. In some examples, the method 200 is performed by the queue manager 150 of FIG. 1. Although shown in a particular sequence or order, unless otherwise specified, the order of the processes may be modified. Thus, the examples described should be understood as examples only, and the processes described may be performed in a different order and some processes may be performed in parallel. Also, in various examples, one or more processes may be omitted. Thus, not all processes are required in every example. Other method flows are possible.
[0032] At operation 205, the processing device may determine a number of commands contained within a plurality of queues of a memory die of the memory subsystem, where each command may be associated with a separate operation to be performed on the memory subsystem, and each queue of the plurality of queues may be associated with a separate priority level and may be configured to maintain a separate set of commands to be performed on the memory subsystem.
[0033] At operation 210, the processing device may assign the command to a queue among the multiple queues based at least in part on the number of commands contained in the queue.
[0034] In operation 215, the processing device may issue one or more commands from a respective set of commands of the multiple queues based at least in part on the respective priority levels.
[0035] In some examples, the method 200 may include prohibiting each of the multiple queues with a number of commands above a threshold from accepting additional commands until the number of commands falls below the threshold.
[0036] In some examples, method 200 may include allocating one or more additional commands to each queue whose respective number of commands is below a threshold, and issuing the one or more additional commands from each queue based at least in part on the respective priority level.
[0037] In some examples, the method 200 may include issuing all of the commands for each queue for which the number of commands exceeds a threshold. Allocating one or more additional commands to each queue may be based at least in part on issuing all of the commands.
[0038] In some examples, the method 200 may include storing, in a memory of the memory subsystem, at least one command associated with a queue in which the individual number of the commands exceeds a threshold, and assigning a command to the queue based at least in part on the individual number of the commands being below the threshold.
[0039] In some examples of method 200, the threshold is based at least in part on resources of the memory subsystem available to perform operations on the memory subsystem.
[0040] In some examples, the method 200 may include assigning one or more commands associated with operations to be performed on the memory subsystem to a set of queues for multiple memory dies of the memory subsystem, and issuing the commands from the set of queues according to a respective priority level, where each queue in the set of queues may be associated with a respective priority level.
[0041] In some examples, method 200 may include determining a number of active memory dies of a memory subsystem and prohibiting one or more active memory dies of the memory subsystem from accepting additional commands if the number of active memory dies exceeds a threshold.
[0042] In some examples, method 200 may include determining that a number of active memory dies of a memory subsystem exceed a threshold value. Prohibiting one or more active memory dies from accepting additional commands may be based at least in part on a number of commands associated with each of the one or more active memory dies.
[0043] In some examples of method 200, the one or more commands to perform an operation on the memory die include a read command, a write command, a host read command, a host write command, or a combination thereof.
[0044] FIG. 3A illustrates an example of a firmware queue 300a that supports maintaining queues for a memory subsystem according to some examples of the present disclosure. The firmware queue 300-a illustrates a plurality of memory die queues 305 (e.g., LUN queues 305) each including one or more priority queues. For example, a first memory die queue 305 may include priority queues 310, 310-a, and 310-b. In some examples, the priority queue 310 may correspond to a first priority queue, the priority queue 310-a may correspond to a second priority queue, and the priority queue 310-b may correspond to a third priority queue. The priority queue 310 may include a particular command (e.g., a request to complete a command), which may be issued by a local memory controller (e.g., a flash memory controller). In some examples, the local memory controller may issue the command according to the priority level of the individual queues 310 or based on the amount of commands in any particular queue exceeding a threshold. In some examples, commands may be assigned to queues 310 on the fly, which may result in other commands (associated with different priority levels) being temporarily suspended from being issued. By preventing a particular queue from containing a threshold amount of commands, the system may conserve resources that would otherwise result from containing a larger number of commands in an individual queue.
[0045] As discussed herein, the memory die queue 305 may include priority queues 310, 310-a, and 310-b, which may correspond to a first priority queue, a second priority queue, and a third priority queue, respectively. In some examples, the first priority queue 310 may be assigned the highest priority level (e.g., with respect to the second and third priority queues). By assigning the highest priority level to the priority queue 310, any commands associated with an associated memory die placed in the priority queue 310 may be issued (e.g., sent to a local memory controller) before commands in the priority queues 310-a and 310-b. Similarly, the second priority queue 310-a may be assigned an intermediate priority level (e.g., with respect to the first and third priority queues). By assigning the intermediate priority level to the priority queue 310-a, any commands associated with an associated memory die placed in the priority queue 310-a may be issued before commands in the priority queue 310-b. In another example, the third priority queue 310-b may be assigned the lowest priority level (e.g., relative to the first and second priority queues). By assigning the lowest priority level to the priority queue 310-b, any command associated with an associated memory die placed in the priority queue 310-b may be issued only if the priority queues 310 and 310-a are empty (e.g., they do not contain any commands).
[0046] Additionally or alternatively, each priority queue of the memory die queue 305 may be associated with a threshold. That is, if the number of commands in a particular priority queue exceeds a threshold, the system may issue one or more (or all) of the commands in the queue to relieve system resources. Without implementing a threshold for issuing commands from a priority queue, the queue may continue to receive commands to be issued. Thus, the system may conserve resources by not being forced to issue commands that would otherwise have accumulated in the particular queue. As discussed herein, a threshold may be assigned per memory die queue or per priority queue. For example, if a threshold is assigned per memory die queue, the first priority queue 310, the second priority queue 310-a, and the third priority queue 310b of the memory die queue 305 may all be associated with the same threshold. Conversely, if thresholds are assigned per priority queue, the first priority queue 310, the second priority queue 310-a, and the third priority queue 310b of the memory die queue 305 may all be associated with different thresholds.
[0047] As an example, the first memory die queue 305 may include command 328 in priority queue 310 and commands 330 and 330-a in priority queue 310-a. The first memory die queue 305 may also include commands 335, 335-a, and 335-b in priority queue 310-b. In some examples, each of the commands in priority queues 310, 310-a, and 310-b may be different commands received at different times. That is, commands may be entered into priority queues 310, 310-a, and 310-b when they are issued. Thus, because priority queue 310 may be associated with a higher priority level than priority queues 310-a and 310-b, command 328 may be issued before commands 330, 330-a, 335, 335-a, and 335-b.
[0048] However, the third priority queue 310-b may be associated with a threshold that may allow commands 335, 335-a, and 335-b to be issued before one or more of commands 328, 330, and 330-a. For example, the threshold for the third priority queue 310-b (in either a per memory die queue or per priority queue configuration) may be two commands. The threshold may be exceeded because commands 335, 335-a, and 335-b may be in the third priority queue 310-b at the same time (and at the same time as one or more of commands 328, 330, and / or 330-a are included in an individual priority queue). Thus, in some examples, each of commands 335, 335-a, and 335-b may be issued (e.g., one at a time, consecutively, etc.) before any other commands in the memory die queue 305 are issued.
[0049] Additionally, if it is determined that the amount of commands in the third priority queue 310-b exceeds a threshold, the third priority queue 310-b may be temporarily prevented from receiving any additional commands (i.e., the third priority queue 310-b may be “mucked”). During this time (e.g., until any amount of commands are issued that reduces the amount of commands below the threshold), any additional commands assigned to the third priority queue 310b may be temporarily assigned to the memory of the memory subsystem. Once the amount of commands falls below the threshold, the commands temporarily assigned to the memory of the memory subsystem may be moved (e.g., transferred) to a separate priority queue.
[0050] In some examples, the second memory die queue 305-a may include commands 340, 340-a, and 340-b in the priority queue 315-a. The second memory die queue 305-a may also include commands 345, 345-a, and 345-b in the priority queue 315-b. As shown in FIG. 3A, the priority queue 315 may be temporarily empty (e.g., NULL), but may receive one or more commands (e.g., at a later time, different from that shown). In some examples, each of the commands in the priority queues 315-a and 315-b may be different commands received at different times. That is, the commands may be entered into the priority queues 315-a and 315-b as they are issued. In some examples, the commands may be entered at the same time or at a different time than the commands entered into the priority queues 310-a and 310-b of the first memory die queue 305. Priority queue 315-a may be associated with a higher priority level than priority queue 315-b, so that commands 340, 340-a, and 340-b may be issued before commands 345, 345-a, and 345-b.
[0051] As discussed above with respect to memory die queue 305, each priority queue of memory die queue 305-a may be associated with a threshold. That is, if the number of commands in a particular priority queue exceeds a threshold, the system may issue one or more (or all) of the commands in that queue to relieve system resources. As discussed herein, a threshold may be assigned per memory die queue or per priority queue. For example, if a threshold is assigned per memory die queue, the first priority queue 315, the second priority queue 315-a, and the third priority queue 315-b of memory die queue 305-a may all be associated with the same threshold. This threshold may be, for example, the same or different threshold as the priority queues of memory die queue 305-a. Conversely, if a threshold is assigned per priority queue, the first priority queue 315, the second priority queue 315-a, and the third priority queue 315-b of memory die queue 305-a may all be associated with different thresholds. As with the thresholds per memory die queue, this threshold may be the same or different than the priority queue thresholds for memory die queue 305-a, for example.
[0052] As an example, the second memory die queue 305-a may include commands 340, 340-a, and 340-b in the second priority queue 315-a and commands 345, 345-a, and 345-b in the second priority queue 315-b. In some examples, each of the commands in the priority queues 315-a and 315-b may be different commands received at different times. That is, the commands may be entered into the priority queues 315-a and 315-b as they are issued. Thus, because the priority queue 310-a may be associated with a higher priority level than the priority queue 315-b, the commands 340, 340-a, and 340-b may be issued before the commands 345, 345-a, and 345-b.
[0053] However, the third priority queue 315-b may be associated with a threshold that may allow commands 345, 345-a, and 345-b to be issued before one or more of commands 340, 340-a, and 340-b. For example, the threshold for the third priority queue 315-b (in either a per memory die queue or per priority queue configuration) may be one command. The threshold may be exceeded because commands 345, 345-a, and 345-b may be in the third priority queue 315-b at the same time (and at the same time that one or more of commands 340, 340-a, and 340-b are included in the second priority queue 315-a). Thus, in some examples, each of commands 345, 345-a, and 345-b may be issued (e.g., one at a time, consecutively, etc.) before any other commands in the memory die queue 305-a are issued.
[0054] Additionally, if it is determined that the amount of commands in the third priority queue 315-b exceeds a threshold, the third priority queue 315-b may be temporarily prevented from receiving any additional commands (i.e., the third priority queue 315-b may be “mucked”). During this time (e.g., until any amount of commands are issued that reduces the amount of commands below the threshold), any additional commands assigned to the third priority queue 315-b may be temporarily assigned to a memory of the memory subsystem (e.g., the local memory 125 of the memory subsystem 110 of FIG. 1). Once the amount of commands falls below the threshold, the commands temporarily assigned to the memory of the memory subsystem may be moved (e.g., transferred) to a separate priority queue.
[0055] In some examples, firmware queue 300-a may also include a third memory die queue 305-b and a fourth memory die queue 305-c. The fourth memory die queue 305 may be or represent the nth memory die queue of firmware queue 300-a. That is, firmware queue 300-a may include multiple memory die queues corresponding to memory dies of the memory subsystem. In some examples, third memory die queue 305-b and fourth memory die queue 305-b may each include one or more priority queues for commands. For example, third memory die queue 305-b may include commands 350, 350-a, and 350-b in priority queue 320-a and commands 355, 355-a, and 355-b in priority queue 320-b. As shown in FIG. 3A, a priority queue of the fourth memory die queue 305-c may be temporarily empty (eg, NULL), but may receive one or more commands (eg, at a later time, at a different point in time).
[0056] As discussed with reference to memory die queues 305 and 30-5a, memory die queues 305-b and 305-c may issue commands according to the priority level associated with the respective priority queue and based on the amount of commands in any particular priority queue exceeding a threshold. For example, commands 350, 350-a, and 350-b may be issued before commands 355, 355-a, and 355-b due to the priority level associated with priority queue 320-a and / or due to the amount of commands in priority queue 320-a exceeding a threshold. In other examples, as discussed herein, issuance of commands 350, 350-a, and 350-b may be temporarily suspended (e.g., mucked) if the amount of commands in priority queue 320-b exceeds a threshold. Additionally or alternatively, thresholds associated with the third memory die queue 305-b and / or the fourth memory die queue 305-c may be set based on the amount of available system resources (e.g., the amount of power available to the memory subsystem) and may be set per memory die queue or per priority queue.
[0057] In another example, the threshold may be based on the number of active memory dies of the memory subsystem. For example, if the memory subsystem includes a number of active memory dies that exceeds the threshold, one or more memory dies may be prohibited from receiving commands (regardless of their priority level) until the number of active memory dies falls below the threshold. An active memory die may refer to any memory die that includes at least one command in a particular queue (e.g., a particular priority queue) and / or that is undergoing an access operation. For example, the active memory die threshold may be 10 memory dies. If an eleventh memory die becomes active, at least one of the eleven memory dies may be prohibited from receiving any additional commands until at least one memory die returns to an inactive state (e.g., it is no longer engaged in access operations and / or it no longer includes commands in its priority queue). When sending a command to a memory die that is temporarily blocked from receiving commands, the command may be temporarily assigned to the memory of the memory subsystem. Once the amount of active memory dies falls below the threshold, the commands that were temporarily assigned to the memory of the memory subsystem may be moved (e.g., transferred) to the queues of the individual memory dies.
[0058] In some examples, a particular command may be associated with a predefined priority level. For example, a first priority level (e.g., the highest priority level) may be associated with host read commands. That is, whenever a host read associated with a particular memory die is issued, it may be assigned to the first prioritized queue of the memory die queue associated with the particular die. In other examples, the first priority level (e.g., a medium priority level) may be associated with host write commands, read commands, write commands, erase commands, or a combination thereof. All other types of commands may be associated with a third (or lower) priority level.
[0059] 3B illustrates an example of a global pool 327 according to some examples of the disclosure. The global pool 327 may include one or more commands from the priority queues discussed with reference to FIG. 3A. That is, requests to complete commands may be issued (e.g., released) from the priority queues to the global pool, and the local memory controller may issue associated commands based on the order in which they were entered into the pool. One or more of the commands may be issued based on the amount of commands in the associated priority queue exceeding a threshold. By preventing a particular queue from containing an amount of commands that exceeds a threshold, the system may conserve resources that would otherwise be incurred due to the inclusion of a larger number of commands in an individual queue.
[0060] In some examples, the global pool 327 may include each of the commands discussed with reference to Figure 3A. Commands may be entered (e.g., included) in the global pool 327 based on the order received (e.g., by an individual memory die queue 305), due to the amount of commands in a particular queue exceeding a threshold, an individual priority level associated with the command, or a combination thereof. In some examples, a command in the global pool 327 may correspond to one or more resources (e.g., memory addresses) associated with the command. That is, a command in the global pool 327 may be issued by a local memory controller to access a particular memory cell or group of memory cells.
[0061] The global pool 327 may include commands from each of the memory die queues 305 discussed with reference to Figure 3A. For example, commands 328, 330, 303-a, 335, 335-a, and 335-b from the first memory die queue 305 may be included in the global pool 327. Additionally or alternatively, commands 340, 340-a, 340-b, 345, 345-a, and 345-b from the second memory die queue 305-a may be included along with commands 350, 350-a, 350-b, 355, 355-a, and 355-b from the second memory die queue 305-b. Commands may be entered into the global pool 327 based on the order received at the individual memory die queues 305 due to the amount of commands in a particular queue exceeding a threshold, based on individual priority levels associated with the commands, or a combination thereof.
[0062] In some examples, command 330 from second prioritized queue 310-a of first memory die queue 305 may be the first command in global pool 327. Command 330 may be the first command entered into global pool 327 due to it being received before any command associated with a higher priority (e.g., command 328). In some examples, command 330 may be entered into global pool 327 before other commands associated with the same priority level (e.g., commands 330-a, 340, 340-a, 340-b, 350, 350-a, and / or 350-b) due to command 330 being received first. Stated another way, second prioritized queue 310-a may receive command 350 before any other memory die queue receives and issues a command having the same (or higher) priority level.
[0063] In some examples, command 340 from second prioritized queue 315-a of second memory die queue 305-a may be the next (e.g., second) command in global pool 327. Command 340 may be entered into global pool 327 based on it being received after command 330 but before any command associated with a higher priority (e.g., command 328). In some examples, command 340 may be entered into global pool 327 before other commands associated with the same priority level (e.g., commands 330-a, 340, 340-a, 340-b, 350, 350-a, and / or 350-b) due to command 340 being received first.
[0064] In some examples, command 330-a from second prioritized queue 310-a of first memory die queue 305 may be the next command in global pool 327. Command 330-a may be entered into global pool 327 based on it being received after command 340 but before any command associated with a higher priority (e.g., command 328). In some examples, command 330-a may be entered into global pool 327 before other commands associated with the same priority level (e.g., commands 340-a, 340-b, 350, 350-a, and / or 350-b) due to command 330-a being received first.
[0065] In some examples, command 340-a from the second prioritized queue 315-a of the second memory die queue 305-a may be the next command in the global pool 327. Command 340-a may be entered into the global pool 327 based on it being received after command 350-a but before any command associated with a higher priority (e.g., command 328). In some examples, command 340-a may be entered into the global pool 327 before other commands associated with the same priority level (e.g., commands 340-a, 340-b, 350, 350-a, and / or 350-b) due to command 340-a being received first.
[0066] In some examples, command 335 from the third prioritized queue 310-b of the first memory die queue 305 may be the next command in the global pool 327. Command 335 may be entered into the global pool based on it being received when other memory die queues do not contain a higher priority command. In some examples, command 335 may be entered into the global pool 327 before other commands associated with the same priority level (e.g., commands 335-a, 335-b, 345, 345-a, 345-b, 355, 355-a, and / or 355-b) due to command 335 being received first.
[0067] In some examples, command 328 from the first priority queue 310 of the first memory die queue 305 may be the next command in the global pool 327. Command 328 may be entered into the global pool 327 based solely on its priority. For example, because command 328 is associated with first (e.g., highest priority), it may be entered into the global pool 327 even if other memory die queues contain commands in separate priority queues. For example, the first memory die queue 305 may contain commands 330 and 330-a in the second priority queue 310-a. However, due to the priority of command 328, command 328 may be issued first (e.g., before commands 330 and 330-a).
[0068] In some examples, at this point, the amount of commands in the second priority queue 320-a of the memory die queue 305-b may exceed a threshold. For example, the threshold may be two (2) commands, and each of commands 350, 350-a, and 350-b may be in the priority queue 320-a. Thus, commands 350, 350-a, and 350-b may be issued despite any other higher priority commands being in any other priority queue of the memory subsystem. Until the commands are issued, the second priority queue 320-a of the memory die queue 305-b may be prevented from receiving any additional commands. That is, any commands contained in the priority queue 320-a may be temporarily stored in the memory of the memory subsystem until commands 350, 350-a, and 350-b are issued. Once the command is issued and the number of commands in priority queue 320-a falls below the threshold, priority queue 320-a may resume receiving commands and other commands in global pool 327 may be issued. By preventing a particular queue from containing an amount of commands that exceeds the threshold, the system may conserve resources that would otherwise be incurred due to the inclusion of a larger number of commands in an individual queue.
[0069] In some examples, each of the remaining commands (e.g., commands 340-b, 335-b, 345, 335-a, 345-a, 345-b, 355, 355-a, and 355-b) may be entered into the global pool 327 last. In some examples, the commands may be entered based on the order in which they are received, based on the priority level associated with each command's individual memory die queue, or based on the amount of commands in the associated priority queue exceeding a threshold. As discussed herein, each command in the global pool 327 may be issued by the local memory controller according to the order in which it was entered into the global pool 327. By preventing a particular queue from containing an amount of commands that exceeds a threshold, the system may conserve resources that would otherwise be incurred due to the inclusion of a larger number of commands in an individual queue.
[0070] FIG. 4 illustrates an example of a memory subsystem 400 for maintaining queues according to some examples of the present disclosure. The memory subsystem 400 may include a mailbox 405 that includes one or more commands to be sent to a memory die of the memory subsystem. The commands may be communicated (e.g., sent, routed) to individual memory die queues 415 using a queue manager 410. Each memory die queue 415 may include one or more priority queues, such as priority queues 420, 425, and 430, which may correspond to the first priority queue, the second priority queue, and the third priority queue, respectively, as described with reference to FIG. 3A. To determine the amount of commands associated with each queue, a scoreboard 417 may track (e.g., the scoreboard may maintain a count) the number of commands in each priority queue of each memory die queue 415 of the memory subsystem 400. A memory die manager 435 may issue commands associated with each individual priority queue and may designate the commands as high priority 440 or normal priority 445 (or other priority level). Commands designated as either high priority 440 or normal priority 445 can be issued by the local memory controller.
[0071] The mailbox 405 may hold a set of commands to be sent to various memory die queues 415 of the memory subsystem. For example, as commands are received (e.g., from a host device), the commands may be stored (e.g., temporarily stored) in the mailbox 405. The queue manager 410 may assign commands in the mailbox 405 to individual memory dies, and in some examples, to a particular priority queue of the individual memory die queues 415 based on a priority associated with the command. For example, high priority commands may be assigned to priority queue 420, medium priority commands may be assigned to priority queue 425, and other commands may be assigned to priority queue 430 (or other priority queues).
[0072] In some examples, queue manager 410 may communicate with scoreboard 417 and / or memory die manager 435 to prohibit commands from being assigned to various priority queues and / or memory dies. For example, if a priority queue is macked, queue manager 410 may not send commands to the queue until the amount of commands in the queue falls below a threshold. Also, if an entire die is macked (e.g., due to the number of active memory dies exceeding a threshold), queue manager 410 may refrain from sending commands to one or more active memory dies until the amount of active memory dies falls below a threshold. The number of active memory dies and / or the number of commands contained in each priority queue of a memory subsystem may be managed by scoreboard 417.
[0073] The memory die manager 435 may issue commands contained within the various priority queues of the memory subsystem 400. As discussed herein, the commands may be issued based on their individual priorities and / or based on the amount of commands in any one priority queue exceeding a threshold. Additionally or alternatively, commands associated with a single memory die may be issued based on the active amount of the memory die exceeding a threshold. If one or more commands are issued, the memory die manager 435 may determine the type of command (e.g., read command, write command, host read command, host write command, etc.) and may determine the particular memory cell associated with the command. That is, the memory die manager 435 may associate the command with resources (e.g., addresses of associated memory cells) for issuing and implementing the command. In some examples, the memory die manager 435 may designate any command as high priority 440 or normal priority 445.
[0074] High priority commands 440 may include any command that is issued (e.g., issued immediately) based on its priority level and / or threshold being exceeded. For example, if a command is received and entered into the first priority queue 420 while a command is being issued from the intermediate priority queue 425, the memory die manager 435 may designate the newly received command as a high priority 440 command. Thus, the local memory controller may issue the command before issuing any other lower priority commands (which may be designated as normal priority 445). Similarly, if a threshold of active memory dies and / or a threshold of commands in a priority queue are exceeded, the memory die manager 435 may make any associated command a high priority 440 command. Thus, the local memory controller may issue the command before issuing any other lower priority commands (which may be designated as normal priority 445). Issuing commands in this manner may allow the system to conserve resources that would otherwise be incurred due to the inclusion of a larger number of commands in a separate queue or in a larger number of memory dies.
[0075] FIG. 5 illustrates an exemplary machine, computer system 500, that supports maintaining queues for a memory subsystem according to examples as disclosed herein. The computer system 500 may include a set of instructions for causing the machine to perform any one or more of the techniques described herein. In some examples, the computer system 500 may correspond to a host system (e.g., the host system 105 described with reference to FIG. 1) that includes, is coupled with, or utilizes a memory subsystem (e.g., the memory subsystem 110 described with reference to FIG. 1) or may be used to perform operations of a controller (e.g., to execute an operating system to perform operations corresponding to the queue manager 150 described with reference to FIG. 1). In some examples, the machine may be connected (e.g., networked) with other machines in a local area network (LAN), an intranet, an extranet, and / or the Internet. The machine may operate in the capacity of a server or client machine in a client-server network environment, as a peer machine in a peer-to-peer (or distributed) network environment, or as a server or client machine in a cloud computing infrastructure or environment.
[0076] The machine may be a personal computer (PC), tablet PC, set-top box (STB), personal digital assistant (PDA), mobile phone, web appliance, server, network router, switch or bridge, or any machine capable of executing a set of instructions (sequential or otherwise) that specify actions to be performed by the machine. Additionally, although a single machine is described, the term "machine" may also include any collection of machines that individually or collectively execute a set (or multiple sets) of instructions to perform any one or more of the methodologies discussed herein.
[0077] The exemplary computer system 500 may include a processing device 505, a main memory 510 (e.g., ROM, flash memory, DRAM such as SDRAM or Rambus DRAM (RDRAM), etc.), a static memory 515 (e.g., flash memory, static RAM (SRAM), etc.), and a data storage system 525, which communicate with each other via a bus 545.
[0078] The processing device 505 represents one or more general-purpose processing devices, such as a microprocessor or a central processing device. More specifically, the processing device may be a complex instruction set computing (CISC) microprocessor, a reduced instruction set computing (RISC) microprocessor, a very long instruction word (VLIW) microprocessor, or a processor implementing other instruction sets or a processor implementing a combination of instruction sets. The processing device 505 may also be one or more special-purpose processing devices, such as an ASIC, an FPGA, a DSP, or a network processor. The processing device 505 is configured to execute instructions 535 to perform the operations and steps discussed herein. The computer system 500 may further include a network interface device 520 for communicating over a network 540.
[0079] The data storage system 525 may include a machine-readable storage medium 530 (also known as a computer-readable medium) on which one or more sets of instructions 535 or software embodying any one or more of the methods or functions described herein are stored. The instructions 535 may also reside, completely or at least partially, within the main memory 510 and / or within the processing device 505 during execution by the computer system 500, with the main memory 510 and the processing device 505 also constituting machine-readable storage media. The machine-readable storage medium 530, the data storage system 525, and / or the main memory 510 may correspond to a memory subsystem.
[0080] In one example, instructions 535 include instructions for implementing functionality corresponding to queue manager 550 (e.g., queue manager 150 described with reference to FIG. 1). Although machine-readable storage medium 530 is illustrated as a single medium, the term "machine-readable storage medium" may include a single medium or multiple media that store one or more sets of instructions. The term "machine-readable storage medium" may also include any medium that is capable of storing or encoding a set of instructions for execution by a machine and that causes a machine to perform any one or more of the methods of the present disclosure. The term "machine-readable storage medium" may include, but is not limited to, solid-state memory, optical media, and magnetic media.
[0081] In some examples, an apparatus as described herein may perform one or more methods. An apparatus may include features, circuits, logic, means, or instructions (e.g., a non-transitory computer-readable medium storing instructions executable by a processor) or any combination thereof for performing the following aspects of the disclosure:
[0082] Aspect 1: A method, apparatus, or non-transitory computer-readable medium comprising operations, features, circuits, logic, means, or instructions, or any combination thereof, for determining a number of commands contained in a queue among a plurality of queues of a memory die of a memory subsystem, each command being associated with a distinct operation to be performed on the memory subsystem, each queue of the plurality of queues being associated with a distinct priority level and configured to maintain a distinct set of commands to be performed on the memory subsystem; assigning commands to a queue among the plurality of queues based at least in part on the number of commands contained in the queue; and issuing one or more commands from the distinct set of commands of the plurality of queues based at least in part on the distinct priority levels.
[0083] Aspect 2: The method, apparatus, or non-transitory computer-readable medium of aspect 1, further comprising an operation, feature, circuit, logic, means, or instructions, or any combination thereof, for prohibiting each of a plurality of queues in which the number of commands exceeds a threshold from accepting additional commands until the number of commands falls below the threshold.
[0084] Aspect 3: The method, apparatus, or non-transitory computer-readable medium of aspect 2, further comprising operations, features, circuits, logic, means, or instructions, or any combination thereof, for assigning one or more additional commands to each queue whose respective number of commands is below a threshold, and issuing one or more additional commands from each queue based at least in part on the respective priority levels.
[0085] Aspect 4: The method, apparatus, or non-transitory computer-readable medium of aspect 3, further comprising operations, features, circuits, logic, means, or instructions, or any combination thereof, for issuing all of the commands for each queue for which the number of commands exceeds a threshold, wherein allocating one or more additional commands to each queue is based at least in part on issuing all of the commands.
[0086] Aspect 5: The method, apparatus, or non-transitory computer-readable medium of any of aspects 2-4, further comprising operations, features, circuits, logic, means, or instructions, or any combination thereof, for storing in a memory of a memory subsystem at least one command associated with a queue for which the individual number of commands exceeds a threshold, and assigning commands to the queue based at least in part on the individual number of commands falling below the threshold.
[0087] Aspect 6: The method, apparatus, or non-transitory computer-readable medium of any of aspects 2-5, wherein the threshold is based at least in part on resources of the memory subsystem available for performing operations on the memory subsystem.
[0088] Aspect 7: A method, apparatus, or non-transitory computer-readable medium as in any of aspects 1-6, further comprising operations, features, circuits, logic, means, or instructions, or any combination thereof, for assigning one or more commands associated with operations to be performed on the memory subsystem to a set of queues for multiple memory dies of the memory subsystem, each queue of the set of queues being associated with a distinct priority level, and issuing commands from the set of queues according to the distinct priority levels.
[0089] Aspect 8: The method, apparatus, or non-transitory computer-readable medium of aspect 7, further including operations, features, circuits, logic, means, or instructions, or any combination thereof, for determining a number of active memory dies of the memory subsystem and prohibiting one or more active memory dies of the memory subsystem from accepting additional commands if the number of active memory dies exceeds a threshold.
[0090] Aspect 9: The method, apparatus, or non-transitory computer-readable medium of aspect 8, further comprising an operation, feature, circuit, logic, means, or instructions, or any combination thereof, for determining that a plurality of active memory dies of the memory subsystem exceed a threshold, wherein prohibiting one or more active memory dies from accepting additional commands is based at least in part on a number of commands associated with each of the one or more active memory dies.
[0091] Aspect 10: A method, apparatus, or non-transitory computer-readable medium according to any of aspects 1 to 9, wherein the one or more commands for performing operations on the memory die include a read command, a write command, a host read command, a host write command, or a combination thereof.
[0092] It should be noted that the described techniques include possible implementations, that acts and steps may be rearranged or otherwise modified, and that other implementations are possible. Further, portions from two or more of the methods may be combined.
[0093] Some portions of the preceding detailed description are presented in terms of algorithms and symbolic representations of operations on data bits within a computer memory. These algorithmic descriptions and representations are the means used by those skilled in the data processing arts to most effectively convey the substance of their work to others skilled in the art. An algorithm is here, and generally, conceived to be a self-consistent sequence of operations leading to a desired result. The operations are those requiring physical manipulations of physical quantities. Usually, though not necessarily, these quantities take the form of electrical or magnetic signals capable of being stored, combined, compared and otherwise manipulated. It has proven convenient at times, primarily for reasons of common usage, to refer to these signals as bits, values, elements, symbols, characters, terms, numbers, or the like.
[0094] It should be borne in mind, however, that all of these and similar terms are associated with the appropriate physical quantities and are merely convenient labels applied to these quantities. This disclosure may refer to actions and processes of a computer system or similar electronic computing device that manipulate and transform data represented as physical (electronic) quantities in the computer system's registers and memory into other data that are similarly represented as physical quantities in the computer system's memory or registers, or other such information storage system.
[0095] The present disclosure also relates to an apparatus for performing the operations herein. This apparatus may be specially constructed for the intended purposes or may include a general purpose computer selectively activated or reconfigured by a computer program stored in the computer. Such a computer program may be stored in a computer readable storage medium, such as, but not limited to, any type of disk, including floppy disks, optical disks, CD-ROMs, and magneto-optical disks, ROM, RAM, EPROM, EEPROM, magnetic or optical cards, or any type of medium suitable for storing electronic instructions, each coupled to a computer system bus.
[0096] The algorithms and displays presented herein are not inherently related to any particular computer or other apparatus. Various general-purpose systems may be used with programs in accordance with the teachings herein, or it may prove convenient to construct more specialized apparatus to carry out the methods. Structures for a variety of these systems may appear in the description that follows. Also, the present disclosure has not been described with reference to any particular programming language. It will be understood that a variety of programming languages may be used to implement the teachings of the disclosure as described herein.
[0097] The present disclosure may be provided as a computer program product or software that may include a machine-readable medium having instructions stored thereon that may be used to program a computer system (or other electronic device) to perform a process according to the present disclosure. A machine-readable medium includes any mechanism for storing information in a form readable by a machine (e.g., a computer). In some examples, a machine-readable (e.g., computer-readable) medium includes a machine (e.g., computer) readable storage medium such as ROM, RAM, magnetic disk storage media, optical storage media, flash memory components, and the like.
[0098] In the foregoing specification, examples of the disclosure have been described with reference to specific examples thereof. It will be apparent that various modifications may be made thereto without departing from the broader spirit and scope of the examples of the disclosure as set forth in the following claims. The specification and drawings are, therefore, to be regarded in an illustrative rather than a restrictive sense.
Claims
1. determining a number of commands contained in a queue among a plurality of queues of a memory die of a memory subsystem, each command being associated with a distinct operation to be performed on the memory subsystem, each queue of the plurality of queues being associated with a distinct priority level and configured to maintain a distinct set of commands to be performed on the memory subsystem; assigning commands to the queues of the plurality of queues based at least in part on the number of commands contained in the queue; issuing one or more commands from the respective set of commands in the plurality of queues based at least in part on the respective priority level; determining a number of active memory dies of the memory subsystem; prohibiting one or more active memory dies of the memory subsystem from accepting additional commands if the number of active memory dies exceeds a threshold; assigning one or more commands associated with operations to be performed on the memory subsystem to a set of queues for a plurality of memory dies of the memory subsystem, each queue of the set of queues being associated with a distinct priority level; issuing commands from said set of queues according to said individual priority levels; The method includes:
2. Prohibiting each of the plurality of queues having a number of commands exceeding a threshold from accepting additional commands until the number of commands falls below the threshold. The method of claim 1 further comprising:
3. allocating one or more additional commands to each queue for which the individual number of commands is below said threshold; issuing the one or more additional commands from each queue based at least in part on the respective priority levels. The method of claim 2 further comprising:
4. issuing all of the commands for each queue for which the number of commands exceeds the threshold, and wherein allocating one or more additional commands to each queue is based at least in part on issuing all of the commands. The method of claim 3 further comprising:
5. storing in a memory of the memory subsystem at least one command associated with a queue for which a distinct number of commands exceeds the threshold; assigning the commands to the queue based at least in part on the respective number of commands falling below the threshold. The method of claim 2 further comprising:
6. The method of claim 2 , wherein the threshold is based at least in part on resources of the memory subsystem available to perform operations on the memory subsystem.
7. determining that a plurality of active memory dies of the memory subsystem exceed the threshold, wherein prohibiting one or more active memory dies from accepting additional commands is based at least in part on a number of commands associated with each of the one or more active memory dies; The method of claim 1 further comprising:
8. 10. The method of claim 1, wherein the one or more commands to perform an operation on the memory die include a read command, a write command, a host read command, a host write command, or a combination thereof.
9. A plurality of memory components; operatively coupled to the plurality of memory components; determining a number of commands contained within one of a plurality of queues of a memory die of a memory subsystem, the commands being associated with distinct operations to be performed on the memory subsystem, each queue of the plurality of queues being associated with a distinct priority level and configured to maintain a distinct set of commands to be performed on the memory subsystem; assigning commands to the queues based at least in part on the number of commands contained in the queue; sending one or more commands from the respective sets of commands of the plurality of queues to one or more of the plurality of memory components based at least in part on the respective priority levels; determining a number of active memory dies of the memory subsystem; prohibiting one or more active memory dies of the memory subsystem from accepting additional commands if the number of active memory dies exceeds a threshold; assigning one or more commands associated with operations to be performed on the memory subsystem to a set of queues for a plurality of memory dies of the memory subsystem, each queue of the set of queues being associated with a distinct priority level; issuing commands from said set of queues according to said individual priority levels; a processing device configured to Including, the system.
10. The processing device comprises: prohibiting each of the plurality of queues in which a number of commands exceeds a threshold from accepting additional commands until the number of commands meets the threshold. It is further configured to The system of claim 9.
11. The processing device comprises: allocating one or more additional commands to each queue containing a number of commands not exceeding said threshold; transmitting the one or more additional commands from the respective queues based at least in part on the respective priority levels. It is further configured to The system of claim 10.
12. The processing device comprises: transmitting all of the commands associated with each queue in which the number of commands exceeds the threshold, wherein adding one or more additional commands to each queue containing the number of commands that exceeds the threshold is based at least in part on issuing all of the commands. It is further configured to The system of claim 11.
13. The processing device comprises: storing in a memory component at least one command associated with a queue that includes the number of commands that exceeds the threshold; assigning the commands to the queues based at least in part on the number of commands in the respective queues falling below the threshold; It is further configured to The system of claim 10.
14. determining a number of commands contained in a queue among a plurality of queues of a memory die of a memory subsystem, each command being associated with a distinct operation to be performed on the memory subsystem, each queue of the plurality of queues being associated with a distinct priority level and configured to maintain a distinct set of commands to be performed on the memory subsystem; assigning commands to the queues of the plurality of queues based at least in part on the number of commands contained in the queue; issuing one or more commands from the respective set of commands in the plurality of queues based at least in part on the respective priority level; determining a number of active memory dies of the memory subsystem; prohibiting one or more active memory dies of the memory subsystem from accepting additional commands if the number of active memory dies exceeds a threshold; assigning one or more commands associated with operations to be performed on the memory subsystem to a set of queues for a plurality of memory dies of the memory subsystem, each queue of the set of queues being associated with a distinct priority level; issuing commands from said set of queues according to said individual priority levels; A non-transitory computer-readable storage medium comprising instructions that, when executed by a processing device, cause the processing device to:
15. The processing device comprises: prohibiting each of the plurality of queues in which the number of commands exceeds a threshold from accepting additional commands until the number of commands falls below the threshold.
15. The non-transitory computer-readable storage medium of claim 14, further comprising:
16. The processing device comprises: allocating one or more additional commands to each queue for which the individual number of commands is below said threshold; issuing the one or more additional commands from each queue based at least in part on the respective priority levels.
20. The non-transitory computer-readable storage medium of claim 15, further comprising:
17. The processing device comprises: issuing all of the commands for each queue for which the number of commands exceeds the threshold, and wherein allocating one or more additional commands to each queue is based at least in part on issuing all of the commands.
20. The non-transitory computer-readable storage medium of claim 16, further comprising:
18. The processing device comprises: storing in a memory of the memory subsystem at least one command associated with a queue for which a distinct number of commands exceeds the threshold; assigning the commands to the queue based at least in part on the respective number of commands falling below the threshold.
20. The non-transitory computer-readable storage medium of claim 15, further comprising:
Citation Information
Patent Citations
Reduction of NVM access conflicts of IO command
CN107885456A
Dynamic queue priority ordering system for data processing system and device therefor
JP1997198264A
Storage system, information processing system, and control method
JP2017162068A
Latency-Aware Memory Control
US20150095605A1
Contention reduction scheduler for NAND flash array with raid
US20180173460A1
