Dynamic Program Pause Disabled for Random Write SSD Workloads

Abstract

An embodiment of an electronic device may include one or more substrates and a controller coupled to the one or more substrates, the controller including circuitry for controlling access to a NAND-based storage medium including a plurality of NAND devices, determining whether a current workload for a particular NAND device of the plurality of NAND devices is a random write workload, and if so, disabling a program suspend operation for only the particular NAND device. Other embodiments are disclosed and claimed.

Description

[Technical Field]

[0001] [CROSS-REFERENCE TO RELATED APPLICATIONS] This application claims the benefit of U.S. Patent Application No. 17 / 241,976, filed April 27, 2021, which is incorporated herein by reference in its entirety. [Background technology]

[0002] Certain NAND media devices may allow either a single read or a single program operation command (i.e., a write command) to access a NAND device or a NAND array within a NAND device at a time. Here, a NAND array may include a series of NAND strings, which may include multiple NAND cells. A program operation may be suspended to accommodate a waiting read operation, and the program operation may then resume once the read operation is complete. This is called a suspend-resume program operation. The latency of a program operation may be an order of magnitude greater than the latency of a read operation. To improve the latency of read operations, NAND solid-state drives (SSDs) utilize the program operation suspend-resume (PSR) feature of the NAND device to suspend (pause) an ongoing program operation to the NAND array, advance one or more queued read operations, and resume the suspended program operation after they are completed. A program operation to a NAND device or a NAND array within a NAND device involves a write operation to the NAND media. A program operation may be performed to program (i.e., write) NAND, such as multi-level cell (MLC) NAND. Program operations may also be performed on other types of NAND (e.g., quad-level cell (QLC), tri-level cell (TLC), single-level cell (SLC), etc.) and other types of non-volatile memory. [Brief explanation of the drawings]

[0003] The material described herein is illustrated by way of example, and not by way of limitation, in the accompanying drawings. For simplicity and clarity of illustration, elements illustrated in the drawings have not necessarily been drawn to scale. For example, the dimensions of some elements may be exaggerated relative to other elements for clarity. Furthermore, where considered appropriate, reference numerals have been repeated among the drawings to indicate corresponding or similar elements. The drawings are as follows:

[0004] [Figure 1] FIG. 1 is a block diagram of an example electronic storage system according to one embodiment.

[0005] [Figure 2] FIG. 1 is a block diagram of an example of an electronic device, according to one embodiment.

[0006] [Figure 3A] 1 is a flowchart illustrating an example of a storage control method according to one embodiment. [Figure 3B] 1 is a flowchart illustrating an example of a storage control method according to one embodiment.

[0007] [Figure 4] 10 is a flowchart of another example of a storage control method according to one embodiment.

[0008] [Figure 5] 10 is a flowchart of another example of a storage control method according to one embodiment.

[0009] [Figure 6] FIG. 10 is an illustration of timing of various NAND operations compared to a baseline according to one embodiment.

[0010] [Figure 7] FIG. 2 is a block diagram of another example of a computing system according to one embodiment.

[0011] [Figure 8] FIG. 1 is a block diagram of an example solid-state drive (SSD) device, according to one embodiment. DETAILED DESCRIPTION OF THE INVENTION

[0012] One or more embodiments or implementations are now described with reference to the accompanying drawings. While particular configurations and arrangements are described, it should be understood that this is done for illustrative purposes only. Those skilled in the art will recognize that other configurations and arrangements may be used without departing from the spirit and scope of the present description. It will be apparent to those skilled in the art that the techniques and / or arrangements described herein may also be used in a variety of other systems and applications other than those described herein.

[0013] Although the following description describes various implementation examples that may be manifested in architectures such as, for example, system-on-chip (SoC) architectures, implementation of the techniques and / or arrangements described herein is not limited to a particular architecture and / or computing system and may be implemented by any architecture and / or computing system of similar purpose. For example, the techniques and / or arrangements described herein may be implemented by various architectures using, for example, multiple integrated circuit (IC) chips and / or packages, and / or various computing devices and / or consumer electronics (CE) devices such as set-top boxes, smartphones, etc. Furthermore, although the following description may include numerous specific details, such as, for example, logic implementations, types and interrelationships of system components, and logic partitioning / integration options, claimed subject matter can be practiced without such specific details. In other instances, some material, such as, for example, control structures and complete software instruction sequences, may not be shown in detail in order to avoid obscuring the material disclosed herein.

[0014] The material disclosed herein may be implemented in hardware, firmware, software, or any combination thereof. The material disclosed herein may also be implemented as instructions stored on a machine-readable medium, which may be read and executed by one or more processors. A machine-readable medium may include any medium and / or mechanism for storing or transmitting information in a form readable by a machine (e.g., a computing device). For example, machine-readable media may include read-only memory (ROM); random access memory (RAM); magnetic disk storage media; optical storage media; flash memory devices; electrical, optical, acoustic, or other forms of propagated signals (e.g., carrier waves, infrared signals, digital signals, etc.), and others.

[0015] References herein to "one implementation," "one implementation," "one exemplary implementation," etc. indicate that the described implementation may include a particular feature, structure, or characteristic, but that not every embodiment necessarily includes such a particular feature, structure, or characteristic. Moreover, such phrases do not necessarily refer to the same implementation. Furthermore, when a particular feature, structure, or characteristic is described in connection with one embodiment, it is stated that it is within the knowledge of one skilled in the art that such feature, structure, or characteristic may also be provided in connection with other implementations, whether or not explicitly described herein.

[0016] Various embodiments described herein may include memory components and / or interfaces to memory components. Such memory components may include volatile and / or nonvolatile (NV) memory. Volatile memory may be a storage medium that requires power to maintain the state of data stored on the medium. Non-limiting examples of volatile memory may include various types of RAM, such as dynamic RAM (DRAM) or static RAM (SRAM). One particular type of DRAM may be used in memory modules and is synchronous dynamic RAM (SDRAM). NV memory (NVM) may be a storage medium that does not require power to maintain the state of data stored on the medium. In one embodiment, the memory device may include a block-addressable memory device, such as one based on NAND technology. In one embodiment, the memory device may or may not include a memory device using NAND flash memory or other memory with multiple threshold levels. A memory device may refer to the die itself and / or a packaged memory product.

[0017] 1 , one embodiment of an electronic storage system 10 may include a NAND-based storage medium 12 including a plurality of NAND devices, and a controller 11 communicatively coupled to the NAND-based storage medium 12. For example, a NAND device may correspond to one NAND die. The controller 11 may include circuitry 13 that determines whether a current workload for a particular NAND device among the plurality of NAND devices is a random write workload, and if so, disables a program suspend operation for only the particular NAND device. In some embodiments, the circuitry 13 may be further configured to determine whether a host read is pending for the particular NAND device, and if so, enable a program suspend operation for only the particular NAND device.

[0018] For example, the circuit 13 may be configured to maintain a command queue (e.g., a NAND device queue (NDQ)) for each of the multiple NAND devices, maintain a counter value associated with each of the command queues, and count each host read for each of the command queues. In some embodiments, the circuit 13 may be further configured to increment a counter value associated with the command queue of a specific NAND device when a command from a host read is placed in the command queue of the specific NAND device, and to decrement the counter value associated with the command queue of the specific NAND device when a command from a host read is cleared from the command queue of the specific NAND device. For example, the circuit 13 may be configured to determine that a current workload for a specific NAND device of the multiple NAND devices is a random write workload when the counter value associated with the command queue of the specific NAND device is zero, and to determine that a host read is pending for the specific NAND device when the counter value associated with the command queue of the specific NAND device is non-zero. In any of the embodiments herein, the controller 11 and the NAND-based storage medium 12 may be incorporated into a solid-state drive (SSD).

[0019] Each embodiment of the controller 11, NAND-based storage medium 12, circuitry 13, and other system components described above may be implemented in hardware, software, or any suitable combination thereof. For example, hardware implementations may include configurable logic, such as programmable logic arrays (PLAs), field programmable gate arrays (FPGAs), or complex programmable logic devices (CPLDs), or fixed-function logic hardware using circuit technologies, such as application-specific integrated circuits (ASICs), complementary metal-oxide semiconductor (CMOS), or transistor-transistor logic (TTL) technology, or any combination thereof. Embodiments of the controller 11 may include general-purpose controllers, special-purpose controllers, memory controllers, storage controllers, microcontrollers, general-purpose processors, special-purpose processors, central processor units (CPUs), execution units, etc. In some embodiments, the NAND-based storage medium 12, circuitry 13, and / or other system memory may be located within or co-located (e.g., on the same die) with various components, including the controller 11.

[0020] Alternatively, or in addition, all or some of these components may be implemented in one or more modules as a set of logic instructions stored in a machine-readable or computer-readable storage medium (e.g., RAM, ROM, programmable ROM (PROM), firmware, flash memory, etc.) for execution by a processor or computing device. For example, computer program code for carrying out operations of the components may be written in any combination of one or more programming languages ​​applicable / suitable for an operating system (OS), including object-oriented programming languages ​​such as Python, Perl, Java, Smalltalk, C++, C#, etc., and conventional procedural programming languages ​​such as the “C” programming language or similar programming languages. For example, NAND-based storage medium 12, other NAND-based storage medium, or other system memory may store a set of instructions that, when executed by controller 11, causes system 10 to implement one or more components, features, or aspects of system 10 (e.g., circuit 13 determines whether a current workload for a particular NAND device is a random write workload, disables a program suspend operation only for a particular NAND device, etc.).

[0021] 2, an embodiment of electronic device 14 may include one or more substrates 15 and a controller 16 coupled to the one or more substrates 15. Controller 16 may include circuitry 17 that controls access to a NAND-based storage medium including a plurality of NAND devices, determines whether a current workload for a particular NAND device among the plurality of NAND devices is a random write workload, and if so, disables a program suspend operation for only the particular NAND device. In some embodiments, circuitry 17 may be further configured to determine whether a host read is pending for the particular NAND device, and if so, enable a program suspend operation for only the particular NAND device.

[0022] For example, circuit 17 may be configured to maintain a command queue for each of the multiple NAND devices, maintain a counter value associated with each of the command queues, and count each host read for each of the command queues. In some embodiments, circuit 17 may be further configured to increment a counter value associated with the command queue of a particular NAND device when a command from a host read is placed in the command queue of the particular NAND device, and to decrement the counter value associated with the command queue of the particular NAND device when a command from a host read is cleared from the command queue of the particular NAND device. For example, circuit 17 may be configured to determine that a current workload for a particular NAND device of the multiple NAND devices is a random write workload when the counter value associated with the command queue of the particular NAND device is zero, and to determine that a host read is pending for the particular NAND device when the counter value associated with the command queue of the particular NAND device is non-zero. In any of the embodiments herein, the controller and NAND-based storage medium may be incorporated into a solid-state drive (SSD).

[0023] Embodiments of circuit 17 may be implemented in a system, apparatus, computer, device, etc. (e.g., such as those described herein). More specifically, hardware implementations of circuit 17 may include configurable logic, e.g., PLA, FPGA, CPLD, or fixed-function logic hardware using circuit technologies, e.g., ASIC, CMOS, or TTL technology, or any combination thereof. Alternatively, or additionally, circuit 17 may be implemented in one or more modules as a set of logic instructions stored in a machine-readable or computer-readable storage medium (e.g., RAM, ROM, PROM, firmware, flash memory, etc.) for execution by a processor or computing device. For example, computer program code for carrying out operations of the components may be written in any combination of one or more programming languages ​​applicable / appropriate to the OS, including object-oriented programming languages ​​such as Python, Perl, Java, Smalltalk, C++, C#, etc., and conventional procedural programming languages ​​such as the “C” programming language or similar programming languages.

[0024] For example, circuit 17 may be implemented in a semiconductor device, which may include one or more substrates 15 to which circuit 17 is coupled. In some embodiments, circuit 17 may be implemented at least partially in one or more of configurable logic and fixed-function hardware logic on a semiconductor substrate (e.g., silicon, sapphire, gallium arsenide, etc.). For example, circuit 17 may include a transistor array and / or other integrated circuit components coupled to substrate 15 with transistor channel regions disposed within substrate 15. The interface between circuit 17 and substrate 15 need not be an abrupt junction. Circuit 17 may also be considered to include an epitaxial layer grown on an initial wafer of substrate 15.

[0025] 3A-3B, an embodiment of a method 20 for controlling storage may include controlling access to a NAND-based storage medium including a plurality of NAND devices at block 21, determining whether a current workload for a particular NAND device of the plurality of NAND devices is a random write workload at block 22, and if so, disabling program suspend operations for only the particular NAND device at block 23. Some embodiments of method 20 may further include determining whether a host read is pending for the particular NAND device at block 24, and if so, enabling program suspend operations for only the particular NAND device at block 25.

[0026] For example, method 20 may also include maintaining a command queue for each of the plurality of NAND devices at block 26, and maintaining a counter value associated with each of the command queues to count each host read for each of the command queues at block 27. Some embodiments of method 20 may further include incrementing a counter value associated with the command queue of the particular NAND device when a command from a host read is placed in the command queue of the particular NAND device at block 28, and decrementing a counter value associated with the command queue of the particular NAND device when a command from a host read is cleared from the command queue of the particular NAND device at block 29. For example, method 20 may also include determining that a current workload for a particular NAND device of the plurality of NAND devices is a random write workload if the counter value associated with the command queue of the particular NAND device is zero at block 30, and / or determining that a host read is pending for the particular NAND device if the counter value associated with the command queue of the particular NAND device is non-zero at block 31. In any of the embodiments herein, the NAND-based storage media may be incorporated into an SSD at block 32.

[0027] Embodiments of method 20 may be implemented in, for example, a system, apparatus, computer, device, etc., such as those described herein. More specifically, hardware implementations of method 20 may include configurable logic, such as PLA, FPGA, CPLD, coarse-grained reconfigurable fabric (CGRA), or fixed-function logic hardware using circuit technologies, such as ASIC, CMOS, or TTL technology, or any combination thereof. Alternatively, or additionally, method 20 may be implemented in one or more modules as a set of logic instructions stored in a machine-readable or computer-readable storage medium (e.g., RAM, ROM, PROM, firmware, flash memory, etc.) for execution by a processor or computing device. For example, computer program code for carrying out operations of the components may be written in any combination of one or more programming languages ​​applicable / appropriate to the OS, including object-oriented programming languages ​​such as Python, Perl, Java, Smalltalk, C++, C#, etc., and conventional procedural programming languages, such as the “C” programming language or similar programming languages.

[0028] For example, method 20 may be implemented in a computer-readable medium as described in connection with Examples 22-28 below. Embodiments of method 20, or portions thereof, may be implemented in firmware, an application (e.g., through an application programming interface (API)), or driver software running on an operating system (OS). Additionally, logic instructions may include assembler instructions, instruction set architecture (ISA) instructions, machine instructions, machine-dependent instructions, microcode, state setting data, configuration data for integrated circuits, state information that individualizes electronic circuits and / or other structural components specific to hardware (e.g., a host processor, central processing unit / CPU, microcontroller, etc.).

[0029] Advantageously, some embodiments may provide techniques for optimizing random write performance of SSDs. Some NAND media systems allow the NAND array to be accessed with either a program command (i.e., a write) or a read command at a time. Because program latency can be an order of magnitude larger than read latency, to improve host read latency (e.g., a metric important to SSD users), some NAND SSDs may utilize a program suspend-resume (PSR) feature of the NAND SSD, which allows an ongoing program operation to be suspended (paused) and then resumed after one or more queued host reads have completed.

[0030] One bottleneck for random write workload throughput in SSDs is NAND programming time (tProg). During random write workloads, SSDs internally read invalid data from the NAND array and program it to new locations, freeing up new, unwritten areas. The problem is that suspension of program operations due to incoming internal reads during random write workloads increases the time required to complete program commands, thus contributing to overhead that bottlenecks random write workload throughput. Advantageously, some embodiments provide techniques that improve random write performance of SSDs with little or no impact on host read latency.

[0031] Some embodiments provide techniques for clearing or disabling PSR commands during random write workloads (but not any other workloads). Advantageously, some embodiments allow for the effective tProg to be reduced or minimized, thereby increasing utilization of available SSD controller bandwidth for NAND device operations. Some embodiments may be effectively utilized for random write workloads because, since there are no host reads during random write workloads, the SSD can improve or optimize the workload for host throughput during random write workloads while also ensuring no impact on host read latency for other workloads. Advantageously, some embodiments may be implemented using relatively low-complexity techniques that provide significant benefits to random write throughput without adversely affecting key SSD metrics (such as host read latency for random reads and any mixed read / write workloads).

[0032] Random write workloads in NAND SSDs result in internal reads by the SSD controller to move data from one NAND location to a new NAND location in order to garbage collect NAND that was written to by the host but is no longer valid, allowing the invalid NAND to be reused for new writes. During the garbage collection process, the SSD controller typically reads any remaining valid host write data from the target eviction NAND device to the SSD controller, allowing the host write data to be corrected with an error correcting code (ECC) algorithm, after which the host write data can be scheduled to be written to its new NAND location. Advantageously, some embodiments distinguish internal reads targeted to the NAND device from host reads targeted to the NAND device, and enable PSR operations only if there is a host read present in the targeted NDQ.

[0033] An SSD controller channel may refer to a dedicated direct memory access (DMA) engine that moves data between the SSD controller and the NAND device. Channel overhead may refer to any additional non-essential DMA command or status command traffic that consumes channel bandwidth.

[0034] In some embodiments, PSR operation is disabled only during random write workloads, advantageously improving random write throughput by reducing or minimizing channel overhead and increasing or maximizing throughput by reducing the effective tProg. However, disabling PSR for other workloads, especially mixed workloads, causes increased read latency because reads must wait for preceding programs to complete before issuing them. In some embodiments, PSR operation is dynamically enabled and disabled so that host read latency is unaffected by mixed read / write workloads. Advantageously, PSR overhead is also reduced or eliminated from random write workloads to improve throughput for random write workloads.

[0035] In some embodiments, dynamic PSR invalidation is performed locally at the per-NAND device level, rather than at the global SSD level. Advantageously, such localized dynamic PSR invalidation can scale to any random write workload that may be localized to only a subset of NAND devices within the SSD. Non-limiting examples of when a random write workload may be localized to only a subset of NAND devices include when the SSD implements NVM Express (NVMe) sets, NVMe Endurance Groups that expose NAND partitioning to the host, etc.; when the SSD implements built-in NAND partitioning in the form of media banking; when the host workload is bursty in its random writes; or when the SSD implements any kind of NVMe host specification that allows any kind of precise or imprecise host write data placement that results in exposing some, but not all, NAND devices to internal reads for garbage collection (e.g., or even media policy).

[0036] Some embodiments may provide techniques to dynamically disable PSR on a per-NAND device basis for localized random write workloads only. Similarly (e.g., additionally or alternatively), some embodiments may provide techniques to enable PSR only when a NAND device is the target of a host read and / or has a pending host read.

[0037] An SSD may incorporate technology that provides a software queue that records NAND commands sent to a NAND device while the NAND device is busy with an ongoing command. In some implementations, the software queue may be referred to as a NAND device queue (NDQ). In some embodiments, a counter (e.g., implemented in the SSD controller) is provided that is maintained to track the number of host reads in the NDQ. This counter is hereinafter referred to as a host read counter (HRC). In some embodiments, the HRC may be the primary mechanism used to determine whether the NDQ management enables or disables PSR operations for the NAND device associated with the NDQ. Each NDQ has its own counter instance, thereby allowing each NAND device to have a localized workload targeted at the NAND device. For example, if an SSD has 10 NAND devices attached to an SSD controller, there will be 10 NDQs and therefore 10 HRCs, one HRC per NDQ. Furthermore, depending on the SSD architecture and host workload, each NDQ may experience a different workload. As such, in the remainder of this specification relating to the embodiments, workload refers to a workload localized per NAND device.

[0038] Referring to FIG. 4, one embodiment of a method 40 for controlling storage may be referred to as NANDCmdEnQueuetoNDQ. Once the SSD controller determines the NAND device target for a new NAND command, the SSD controller is ready to queue the command to the targeted NAND device. The incoming new NAND command is added to the NDQ in box 41. If the new NAND command being placed in the NDQ in box 42 is a NAND command generated from a host read command, the HRC is incremented for the associated NDQ in box 43. If the NAND read command is generated internally by the SSD controller, for example, for garbage collection, the counter is not incremented. Later, when the NAND read command generated from the host read is cleared from the NDQ, the HRC is decremented (see FIG. 5).

[0039] 5, one embodiment of a method 50 for controlling storage may be referred to as NANDCmdDispatchtoNDQ. When any NAND read request (e.g., internal or host) reaches the top of the NDQ at box 51 (e.g., a read request is about to be sent to the SSD controller channel and therefore to the target NAND device), the HRC of that NDQ is evaluated at box 52. If the HRC is zero at box 52 (e.g., meaning the current workload is a random write workload), the PSR is disabled for this command at box 53. Because the NAND read command in this case should be an internal SSD controller read rather than a host read, if there is an outstanding program on the target NAND device, it will be forced to wait until the ongoing program is completed before the (internal) read can be sent to the target NAND device.

[0040] If HRC is not zero in box 52 (meaning, for example, that the current workload includes a NAND command generated from a host read command), then PSR is enabled for this command in box 54. If a program is ongoing on the target device associated with the NDQ, the PSR operation is enabled because the NDQ may be mixed with both host and internal read commands, and a program suspend operation may be issued per PSR policy that may pause the ongoing program and allow the program to be suspended before issuing a NAND read command. Method 50 may then proceed to determining whether a NAND command was issued from a host read in box 55, and if so, decrementing HRC in box 56.

[0041] Disabling PSR when there are no host reads in the NDQ and enabling PSR when there are host reads in the NDQ dynamically ensures that PSR operations and associated channel overhead are eliminated from random write workloads while maintaining the read latency benefits of host read commands in pure read and mixed read / write workloads. Advantageously, when compared to a similarly configured baseline without localized dynamic PSR disabling, some embodiments show significant improvements in input / output operations per second (IOPS), effective tProg, and random write workload performance.

[0042] Referring to Figure 6, an illustrative timing diagram 60 compares an embodiment using localized dynamic PSR invalidation technology to a baseline for one NAND device. As shown in Figure 6, the embodiment using localized dynamic PSR invalidation technology essentially eliminates PSR overhead, and the baseline takes more time for host writes compared to the embodiment using localized dynamic PSR invalidation technology. The improvement in tProg may be due to reduced PSR overhead, which cannot interrupt ongoing program progress while a read is in progress.

[0043] The techniques described herein may be provided in a variety of computing systems (including, for example, non-portable computing devices such as desktops, workstations, servers, rack systems, etc., portable computing devices such as smartphones, tablets, ultra-portable personal computers (UMPCs), laptop computers, Ultrabook computing devices, smart watches, smart glasses, smart bracelets, etc., and / or client / edge devices such as Internet of Things (IoT) devices (e.g., sensors, cameras, etc.)).

[0044] 7, one embodiment of computing system 100 may include one or more processors 102-1 through 102-N (generally referred to herein as "multiple processors 102" or "processor 102"). The multiple processors 102 may communicate via an interconnect or bus 104. Each processor 102 may include various components, only some of which will be described with reference to processor 102-1 for clarity. Accordingly, each of the remaining processors 102-2 through 102-N may include the same or similar components described with reference to processor 102-1.

[0045] In some embodiments, processor 102-1 may include one or more processor cores 106-1 through 106-M (referred to herein as "cores 106" or more generally as "cores 106"), cache 108 (which may be a shared cache or a private cache in various embodiments), and / or router 110. Processor core 106 may be implemented on a single integrated circuit (IC) chip. The chip may further include one or more shared and / or private caches (e.g., cache 108), buses or interconnects (e.g., bus or interconnect 112), memory controllers, or other components.

[0046] In some embodiments, routers 110 may be used to communicate between various components of processor 102-1 and / or system 100. Additionally, processor 102-1 may include more than one router 110. Furthermore, multiple routers 110 may communicate to enable data routing between various components internal or external to processor 102-1.

[0047] The cache 108 may store data (e.g., including instructions) utilized by one or more components (e.g., cores 106) of the processor 102-1. For example, the cache 108 may locally cache data stored in the memory 114 for faster access by the components of the processor 102. As shown in FIG. 7, the memory 114 may communicate with the processor 102 via the interconnect 104. In some embodiments, the (possibly shared) cache 108 may have various levels; for example, the cache 108 may be a mid-level cache and / or a last-level cache (LLC). Additionally, each of the cores 106 may include a level 1 (L1) cache (116-1) (generally referred to herein as “L1 cache 116”). The various components of the processor 102-1 may communicate directly with the cache 108 through a bus (e.g., bus 112) and / or a memory controller or hub.

[0048] 7, memory 114 may be coupled to other components of system 100 through memory controller 120. Memory 114 may include volatile memory and may be referred to interchangeably as main memory or system memory. Although memory controller 120 is shown coupled between interconnect 104 and memory 114, memory controller 120 may be located elsewhere in system 100. For example, in some embodiments, memory controller 120, or portions thereof, may be provided in one of multiple processors 102.

[0049] System 100 can communicate with other devices / systems / networks via network interface 128 (e.g., communicating with a computer network and / or cloud 129 via a wired or wireless interface). For example, network interface 128 may include an antenna (not shown) for communicating wirelessly with network / cloud 129 (e.g., via an Institute of Electrical and Electronics Engineers (IEEE) 802.11 interface (including IEEE 802.11a / b / g / n / ac, etc.), a cellular interface, 3G, 4G, LTE, Bluetooth, etc.).

[0050] System 100 may also include a storage device, such as SSD 130, coupled to interconnect 104 via SSD controller logic 125. Accordingly, logic 125 may control access to SSD 130 by various components of system 100. Additionally, although logic 125 is shown in FIG. 7 as being directly coupled to interconnect 104, logic 125 may alternatively communicate with one or more other components of system 100 via a storage bus / interconnect (e.g., a Serial Advanced Technology Attachment (SATA) bus, a Peripheral Component Interconnect (PCI) (or PCI Express (PCIe) interface), NVM Express (NVMe), etc.) (e.g., when a storage bus is coupled to interconnect 104 via some other logic, such as a bus bridge, a chipset, etc.). Additionally, logic 125 may be incorporated into memory controller logic (e.g., as described with reference to FIG. 8) or may be provided in the same integrated circuit (IC) device (e.g., on the same circuit board device as SSD 130 or in the same housing as SSD 130) in various embodiments.

[0051] Additionally, logic 125 and / or SSD 130 may be coupled to one or more sensors (not shown) to receive information (e.g., in the form of one or more bits or signals) indicative of the status or value of a value detected by the one or more sensors. These sensors may be located in proximity to components of system 100 (or other computing systems described herein), including cores 106, interconnect 104 or 112, components external to processor 102, SSD 130, an SSD bus, a SATA bus, logic 125, circuitry 160, etc., to sense variations in various factors that affect the power / thermal behavior of the system / platform (e.g., temperature, operating frequency, operating voltage, power consumption, and / or communication activity between cores, etc.).

[0052] FIG. 8 illustrates a block diagram of various components of SSD 130, according to one embodiment. As illustrated in FIG. 8, circuit 160 may be located in various locations, such as within SSD 130 or controller 382, ​​and may include similar technology as described in connection with FIG. 7. SSD 130 includes controller 382 (which further includes one or more processor cores or processors 384 and memory controller logic 386), cache 138, RAM 388, firmware storage 390, and one or more NAND devices 392-1 through 392-N (collectively, NAND media 392). NAND media 392 is coupled to memory controller logic 386 via one or more memory channels or buses. SSD 130 also communicates with logic 125 via an interface (such as a SATA, SAS, PCIe, NVMe, or other interface). Processor 384 and / or controller 382 may compress / decompress data being written to or read from NAND devices 392-1 through 392-N.

[0053] As illustrated in FIGS. 7 and 8, SSD 130 may include circuitry 160, which may be in the same housing as SSD 130 and / or may be fully integrated on the printed circuit board (PCB) of SSD 130. One or more of the features / aspects / operations described with reference to FIGS. 1-6 may be performed by one or more of the components of FIGS. 7 and / or 8. Also, one or more of the features / aspects / operations of FIGS. 1-6 may be programmed into firmware 390. Furthermore, SSD controller logic 125 may also include circuitry 160. Advantageously, circuitry 160 may include technology for implementing one or more aspects of system 10 (FIG. 1), device 14 (FIG. 2), method 20 (FIGS. 3A-3B), method 40 (FIG. 4), method 50 (FIG. 5), timing diagram 60 (FIG. 6), and / or any of the features described herein.

[0054] For example, the circuit 160 may be configured to determine whether a current workload for a particular NAND device of one or more NAND devices 392-1 through 392-N is a random write workload, and if so, disable program suspend operations (or, for example, PSR operations) for only the particular NAND device. Advantageously, disabling PSR improves tProg, improving I / O per second or random write performance. In some embodiments, the circuit 160 may be further configured to determine whether a host read is pending for the particular NAND device, and if so, enable program suspend operations for only the particular NAND device.

[0055] For example, the circuit 160 may be configured to maintain an NDQ (e.g., a command queue) for each of the one or more NAND devices 392-1 through 392-N, maintain an HRC (e.g., a counter value) associated with each of the NDQs, and count each host read for each of the NDQs. In some embodiments, the circuit 160 may be further configured to increment the HRC associated with the NDQ of a particular NAND device when a command from a host read is placed in the NDQ of the particular NAND device, and to decrement the HRC associated with the NDQ of the particular NAND device when a command from a host read is cleared from the NDQ of the particular NAND device. For example, the circuit 160 may be configured to determine that a current workload for a particular NAND device of the one or more NAND devices 392-1 through 392-N is a random write workload when the HRC associated with the NDQ of the particular NAND device is zero, and to determine that a host read is pending for the particular NAND device when the HRC associated with the NDQ of the particular NAND device is non-zero.

[0056] In other embodiments, SSD 130 may be replaced with any suitable storage / memory / technology / media. In some embodiments, circuit 160 may be coupled to one or more substrates (e.g., silicon, sapphire, gallium arsenide, printed circuit board (PCB), etc.) and may include channel regions of transistors disposed within the one or more substrates. In other embodiments, SSD 130 may include two or more types of storage media. For example, the majority of the storage may be NAND, and may also include some faster, finer-granularity accessible (e.g., byte-addressable) NVM. SSD 130 may alternatively or additionally include persistent volatile memory (e.g., DRAM or SRAM backed up by a battery or capacitor). For example, SSD 130 may include power loss protection (PLI) technology using an energy storage capacitor. The energy storage capacitor can provide enough energy (power) to complete any ongoing commands and ensure that any data in the DRAM / SRAM is recorded to non-volatile NAND media. The capacitor can act as a backup battery for persistent volatile memory. As shown in Figures 7 and 8, features or aspects of circuitry 160 may be distributed throughout system 100 and / or co-located / integrated with various components of system 100.

[0057] [Additional points to note and examples]

[0058] Example 1 includes an electronic apparatus, the apparatus including one or more substrates and a controller coupled to the one or more substrates, the controller including circuitry to control access to a NAND-based storage medium including a plurality of NAND devices, determine whether a current workload for a particular NAND device of the plurality of NAND devices is a random write workload, and if determined to be so, disable a program suspend operation for only the particular NAND device.

[0059] Example 2 includes the apparatus as described in example 1, wherein the circuitry further determines whether a host read is pending for the particular NAND device, and if so, enables the program suspend operation only for the particular NAND device.

[0060] Example 3 includes the apparatus of example 2, wherein the circuitry further maintains a command queue for each of the plurality of NAND devices and maintains a counter value associated with each of the command queues to count each host read for each of the command queues.

[0061] Example 4 includes the apparatus of example 3, wherein the circuitry further increments a counter value associated with the command queue of the particular NAND device when a command from the host read is placed in the command queue of the particular NAND device, and decrements a counter value associated with the command queue of the particular NAND device when a command from the host read is cleared from the command queue of the particular NAND device.

[0062] Example 5 includes the apparatus of example 4, wherein the circuitry further determines that a current workload for a particular NAND device among the plurality of NAND devices is a random write workload when a counter value associated with a command queue of the particular NAND device is zero.

[0063] Example 6 includes the apparatus of any of Examples 4-5, wherein the circuitry is further configured to determine that a host read is pending for the particular NAND device when a counter value associated with the command queue of the particular NAND device is non-zero.

[0064] Example 7 includes the apparatus of any of examples 1 to 6, wherein the controller and the NAND-based storage medium are incorporated into a solid-state drive.

[0065] Example 8 includes an electronic storage system, the system including a NAND-based storage medium including a plurality of NAND devices, and a controller communicatively coupled to the NAND-based storage medium, the controller including circuitry to determine whether a current workload for a particular NAND device of the plurality of NAND devices is a random write workload, and if so, disable a program suspend operation for only the particular NAND device.

[0066] Example 9 includes the system as described in example 8, wherein the circuitry further determines whether a host read is pending for the particular NAND device, and if so, enables the program suspend operation only for the particular NAND device.

[0067] Example 10 includes the system of example 9, wherein the circuitry further maintains a command queue for each of the plurality of NAND devices, and maintains a counter value associated with each of the command queues to count each host read for each of the command queues.

[0068] Example 11 includes the system of example 10, wherein the circuitry further increments a counter value associated with the command queue of the particular NAND device when a command from the host read is placed in the command queue of the particular NAND device, and decrements a counter value associated with the command queue of the particular NAND device when a command from the host read is cleared from the command queue of the particular NAND device.

[0069] Example 12 includes the system of Example 11, wherein the circuitry further determines that a current workload for a particular NAND device among the plurality of NAND devices is a random write workload when a counter value associated with a command queue of the particular NAND device is zero.

[0070] Example 13 includes the system of any of Examples 11-12, wherein the circuitry further determines that a host read is pending for the particular NAND device when a counter value associated with the command queue of the particular NAND device is non-zero.

[0071] Example 14 includes the system of any of examples 8-13, wherein the controller and the NAND-based storage medium are incorporated into a solid-state drive.

[0072] Example 15 includes a method for controlling storage, the method including controlling access to a NAND-based storage medium including a plurality of NAND devices, determining whether a current workload for a particular NAND device of the plurality of NAND devices is a random write workload, and if so, disabling program suspend operations for only the particular NAND device.

[0073] Example 16 includes the method of example 15, further comprising determining whether a host read is pending for the particular NAND device, and if so, enabling the program suspend operation only for the particular NAND device.

[0074] Example 17 includes the method of example 16, further comprising maintaining a command queue for each of the plurality of NAND devices, and maintaining a counter value associated with each of the command queues to count each host read for each of the command queues.

[0075] Example 18 includes the method of example 17, further including incrementing a counter value associated with the command queue of the particular NAND device when a command from the host read is placed in the command queue of the particular NAND device, and decrementing a counter value associated with the command queue of the particular NAND device when a command from the host read is cleared from the command queue of the particular NAND device.

[0076] Example 19 includes the method of Example 18, further comprising determining that the current workload for a particular NAND device among the plurality of NAND devices is a random write workload if a counter value associated with the command queue of the particular NAND device is zero.

[0077] Example 20 includes the method of any of Examples 18 to 19, further comprising determining that a host read is pending for the particular NAND device if a counter value associated with the command queue of the particular NAND device is non-zero.

[0078] Example 21 includes the method of any of examples 15 to 20, wherein the NAND-based storage medium is incorporated into a solid-state drive.

[0079] Example 22 includes at least one non-transitory machine-readable medium including a plurality of instructions that, when executed on a computing device, cause the computing device to control access to a NAND-based storage medium including a plurality of NAND devices, determine whether a current workload for a particular NAND device of the plurality of NAND devices is a random write workload, and, if determined to be so, disable a program suspend operation for only the particular NAND device.

[0080] Example 23 includes at least one non-transitory machine-readable medium as described in Example 22, the medium including a plurality of additional instructions that, when executed at a computing device, cause the computing device to determine whether a host read is pending for a particular NAND device, and if so, enable a program suspend operation only for the particular NAND device.

[0081] Example 24 includes at least one non-transitory machine-readable medium of Example 23, the medium including a plurality of additional instructions that, when executed on the computing device, cause the computing device to maintain a command queue for each of the plurality of NAND devices, maintain a counter value associated with each of the command queues, and count each host read for each of the command queues.

[0082] Example 25 includes at least one non-transitory machine-readable medium of Example 24, the medium including a plurality of further instructions that, when executed at the computing device, cause the computing device to increment a counter value associated with the command queue of the particular NAND device when a command from the host read is placed in the command queue of the particular NAND device, and to decrement a counter value associated with the command queue of the particular NAND device when a command from the host read is cleared from the command queue of the particular NAND device.

[0083] Example 26 includes at least one non-transitory machine-readable medium as described in Example 25, the medium including a plurality of further instructions that, when executed on a computing device, cause the computing device to determine that a current workload for a particular NAND device of the plurality of NAND devices is a random write workload when a counter value associated with a command queue of the particular NAND device is zero.

[0084] Example 27 includes at least one non-transitory machine-readable medium of any of Examples 25-26, the medium including a plurality of further instructions that, when executed on a computing device, cause the computing device to determine that a host read is pending for the particular NAND device if a counter value associated with a command queue for the particular NAND device is non-zero.

[0085] Example 28 includes the at least one non-transitory machine-readable medium of any of Examples 22 to 27, wherein the NAND-based storage medium is incorporated into a solid-state drive.

[0086] Example 29 includes a storage controller apparatus, the apparatus comprising: means for controlling access to a NAND-based storage medium including a plurality of NAND devices; means for determining whether a current workload for a particular NAND device of the plurality of NAND devices is a random write workload; and, if so, means for disabling a program suspend operation for only the particular NAND device.

[0087] Example 30 includes the apparatus of example 29, further comprising: means for determining whether a host read is pending for the particular NAND device, and if so, means for enabling the program suspend operation only for the particular NAND device.

[0088] Example 31 includes the apparatus of example 30, further comprising: means for maintaining a command queue for each of the plurality of NAND devices; and means for maintaining a counter value associated with each of the command queues to count each host read for each of the command queues.

[0089] Example 32 includes the apparatus of example 31, further comprising: means for incrementing a counter value associated with the command queue of the particular NAND device when a command from the host read is placed in the command queue of the particular NAND device; and means for decrementing the counter value associated with the command queue of the particular NAND device when a command from the host read is cleared from the command queue of the particular NAND device.

[0090] Example 33 includes the apparatus of Example 32, further comprising means for determining that a current workload for a particular NAND device among the plurality of NAND devices is a random write workload when a counter value associated with the command queue of the particular NAND device is zero.

[0091] Example 34 includes the apparatus of any of Examples 32 to 33, further comprising means for determining that a host read is pending for the particular NAND device if a counter value associated with the command queue of the particular NAND device is non-zero.

[0092] Example 35 includes the apparatus of any of examples 29 to 34, wherein the NAND-based storage medium is incorporated into a solid-state drive.

[0093] The term "coupled" may be used herein to refer to any type of direct or indirect relationship between the components in question and may apply to electrical, mechanical, fluid, optical, electromagnetic, electromechanical, or other connections. Additionally, terms such as "first," "second," etc. may be used herein for ease of description only and do not have any particular temporal or chronological meaning unless otherwise indicated.

[0094] In the present application and claims, a series of items followed by the term “one or more of” may refer to any combination of the listed terms. For example, the phrases “one or more of A, B, and C” and “one or more of A, B, or C” may both refer to A; B; C; A and B; A and C; B and C; or A, B, and C. Various components of the systems described herein may be implemented in software, firmware, and / or hardware, and / or any combination thereof. For example, various components of the systems or devices described herein may be provided, at least in part, in the hardware of a computing SoC, such as may be found in a computing system such as a smartphone. Those skilled in the art will recognize that the systems described herein may include additional components not depicted in the corresponding figures. For example, the systems described herein may include additional components, such as bitstream multiplexer or demultiplexer modules, not depicted for clarity.

[0095] Although an implementation of the example processes described herein may include performing all of the operations shown in the order shown, the disclosure is not limited in this respect, and in various examples, an implementation of the example processes herein may include only a subset of the operations shown, operations performed in an order different from that shown, or additional operations.

[0096] Additionally, any one or more of the operations described herein may be performed in response to instructions provided by one or more computer program products. Such program products may include, for example, signal-bearing media providing instructions that, when executed by a processor, may result in the functionality described herein. A computer program product may be provided on one or more machine-readable media in any form. Thus, for example, a processor including one or more graphics processing units or processor cores may execute one or more of the example process blocks described herein in response to program code and / or instructions or instruction sets transmitted to the processor by one or more machine-readable media. In general, a machine-readable medium may carry software in the form of program code and / or instructions or instruction sets that can cause any of the devices and / or systems described herein to implement at least a portion of the operations described herein and / or any portion of the devices, systems, or any modules or components described herein.

[0097] In any implementation described herein, the term "module" refers to any combination of software logic, firmware logic, hardware logic, and / or circuitry configured to provide the functionality described herein. Software may be embodied as a software package, code, and / or instruction set or instructions, and in any implementation described herein, "hardware" may include, for example, hardwired circuitry, programmable circuitry, state machine circuitry, fixed function circuitry, execution unit circuitry, and / or firmware storing instructions executed by programmable circuitry, alone or in any combination. These modules may be embodied collectively or individually as circuitry (e.g., integrated circuits (ICs), systems-on-chips (SoCs), etc.) that forms part of a larger system.

[0098] Various embodiments may be implemented using hardware elements, software elements, or a combination of both. Examples of hardware elements may include processors, microprocessors, circuits, circuit elements (e.g., transistors, resistors, capacitors, inductors, etc.), integrated circuits, application specific integrated circuits (ASICs), programmable logic devices (PLDs), digital signal processors (DSPs), field programmable gate arrays (FPGAs), logic gates, registers, semiconductor devices, chips, microchips, and chipsets. Examples of software may include software components, programs, applications, computer programs, application programs, system programs, machine programs, operating system software, middleware, firmware, software modules, routines, subroutines, functions, methods, procedures, software interfaces, application program interfaces (APIs), instruction sets, computing code, computer code, code segments, computer code segments, words, values, symbols, or any combination thereof. The determination of whether an embodiment is implemented using hardware and / or software elements may depend on any number of factors, such as desired computation rate, power level, thermal tolerance, processing cycle budget, input data rate, output data rate, memory resources, data bus speed, and other design or performance constraints.

[0099] One or more aspects of at least one embodiment may be implemented by representative instructions stored on a machine-readable medium that represent various logic within a processor, and that, when read by a machine, cause the machine to create logic for performing the techniques described herein. Such representations, known as IP cores, may be stored on tangible machine-readable media and supplied to various customers or manufacturing facilities for loading into manufacturing machines that actually create the logic or processor.

[0100] While certain features described herein have been described with reference to various implementations, this description is not intended to be construed in a limiting sense. Accordingly, various modifications of the implementations described herein and other implementations that may be apparent to those skilled in the art to which this disclosure pertains are deemed to be within the spirit and scope of the present disclosure.

[0101] It will be recognized that these embodiments are not limited to the embodiments so described, but may be practiced with modification and alteration without departing from the scope of the appended claims. For example, the above-described embodiments may include a particular combination of features. However, the above-described embodiments are not limited in this respect, and in various implementations, the above-described embodiments may include implementing only a subset of such features, implementing such features in a different order, implementing such features in different combinations, and / or implementing additional features beyond those expressly recited. The scope of these embodiments should, therefore, be determined with reference to the appended claims, along with the full range of equivalents to which such claims are entitled.

Claims

1. one or more substrates; and a controller coupled to the one or more substrates; The controller includes: Controlling access to a NAND-based storage medium including a plurality of NAND devices; determining that a current workload for a particular NAND device is a random write workload when there are no host reads pending for the particular NAND device among the plurality of NAND devices and there are internal reads pending for the particular NAND device; Disabling a program suspend operation for only the specific NAND device in response to determining that the current workload is the random write workload when there are no pending host reads for the specific NAND device and there are pending internal reads for the specific NAND device. The circuit includes the circuit further comprising: determining whether a host read is pending for said particular NAND device; and if so, enabling the program suspend operation only for the specific NAND device; maintaining a command queue for each of the plurality of NAND devices; maintaining a counter value associated with each of said command queues to count each host read for each of said command queues; incrementing the counter value associated with the command queue of the particular NAND device when a command from a host read is placed in the command queue of the particular NAND device; decrementing the counter value associated with the command queue of the particular NAND device when the command from the host read is cleared from the command queue of the particular NAND device; electronic equipment.

2. one or more substrates; and a controller coupled to the one or more substrates; The controller includes: Controlling access to a NAND-based storage medium including a plurality of NAND devices; determining whether a current workload for a particular NAND device among the plurality of NAND devices is a random write workload, and if so, Disables program suspend operations for the specific NAND device only The circuit includes the circuit further comprising: determining whether a host read is pending for said particular NAND device; and if so, enabling the program suspend operation only for the specific NAND device; the circuit further comprising: maintaining a command queue for each of the plurality of NAND devices; maintaining a counter value associated with each of said command queues to count each host read for each of said command queues; the circuit further comprising: incrementing the counter value associated with the command queue of the particular NAND device when a command from a host read is placed in the command queue of the particular NAND device; The electronic device decrements the counter value associated with the command queue of the particular NAND device when the command from the host read is cleared from the command queue of the particular NAND device.

3. the circuit further comprising:

2. The electronic device of claim 1, wherein if the counter value associated with the command queue of the particular NAND device is zero, the electronic device determines that the current workload for the particular NAND device among the plurality of NAND devices is the random write workload.

4. the circuit further comprising: The electronic device of claim 1 , wherein the electronic device determines that the host read is pending for the particular NAND device if the counter value associated with the command queue for the particular NAND device is non-zero.

5. The electronic device of claim 1 , wherein the controller and the NAND-based storage medium are incorporated into a solid-state drive.

6. a NAND-based storage medium including a plurality of NAND devices; and a controller communicatively coupled to the NAND-based storage medium; The controller includes: determining that a current workload for a particular NAND device is a random write workload when there are no host reads pending for the particular NAND device among the plurality of NAND devices and there are internal reads pending for the particular NAND device; and disabling a program suspend operation for only the particular NAND device in response to determining that the current workload is the random write workload when there are no pending host reads for the particular NAND device and there are pending internal reads for the particular NAND device. The circuit includes the circuit further comprising: determining whether a host read is pending for said particular NAND device; and if so, enabling the program suspend operation only for the specific NAND device; maintaining a command queue for each of the plurality of NAND devices; maintaining a counter value associated with each of said command queues to count each host read for each of said command queues; incrementing the counter value associated with the command queue of the particular NAND device when a command from a host read is placed in the command queue of the particular NAND device; decrementing the counter value associated with the command queue of the particular NAND device when the command from the host read is cleared from the command queue of the particular NAND device; Electronic storage systems.

7. a NAND-based storage medium including a plurality of NAND devices; and a controller communicatively coupled to the NAND-based storage medium; The controller includes: determining whether a current workload for a particular NAND device among the plurality of NAND devices is a random write workload, and if so, Disables program suspend operations for the specific NAND device only The circuit includes the circuit further comprising: determining whether a host read is pending for said particular NAND device; and if so, enabling the program suspend operation only for the specific NAND device; the circuit further comprising: maintaining a command queue for each of the plurality of NAND devices; maintaining a counter value associated with each of said command queues to count each host read for each of said command queues; the circuit further comprising: incrementing the counter value associated with the command queue of the particular NAND device when a command from a host read is placed in the command queue of the particular NAND device; decrementing the counter value associated with the command queue of the particular NAND device when the command from the host read is cleared from the command queue of the particular NAND device; Electronic storage systems.

8. the circuit further comprising:

7. The electronic storage system of claim 6, wherein if the counter value associated with the command queue of the particular NAND device is zero, the current workload for the particular NAND device among the plurality of NAND devices is determined to be the random write workload.

9. the circuit further comprising:

7. The electronic storage system of claim 6, wherein the host read is determined to be pending for the particular NAND device if the counter value associated with the command queue for the particular NAND device is non-zero.

10. 10. The electronic storage system of claim 6, wherein the controller and the NAND-based storage medium are incorporated into a solid-state drive.

11. 1. A method for controlling storage, comprising: controlling access to a NAND-based storage medium including a plurality of NAND devices; determining that a current workload for a particular NAND device is a random write workload when there are no host reads pending for the particular NAND device among the plurality of NAND devices and there are internal reads pending for the particular NAND device; disabling a program suspend operation for only the particular NAND device in response to determining that the current workload is the random write workload when there are no pending host reads for the particular NAND device and there are pending internal reads for the particular NAND device; determining whether a host read is pending for the particular NAND device; and if so, enabling the program suspend operation only for the particular NAND device; maintaining a command queue for each of the plurality of NAND devices; maintaining a counter value associated with each of the command queues to count each host read for each of the command queues; incrementing the counter value associated with the command queue of the particular NAND device when a command from a host read is placed in the command queue of the particular NAND device; and decrementing the counter value associated with the command queue of the particular NAND device when the command from the host read is cleared from the command queue of the particular NAND device. A method comprising:

12. 1. A method for controlling storage, comprising: controlling access to a NAND-based storage medium including a plurality of NAND devices; determining whether a current workload for a particular NAND device of the plurality of NAND devices is a random write workload; and if so, disabling a program suspend operation only for the specific NAND device; determining whether a host read is pending for the particular NAND device; and if so, enabling the program suspend operation only for the particular NAND device; maintaining a command queue for each of the plurality of NAND devices; maintaining a counter value associated with each of the command queues to count each host read for each of the command queues; incrementing the counter value associated with the command queue of the particular NAND device when a command from a host read is placed in the command queue of the particular NAND device; and decrementing the counter value associated with the command queue of the particular NAND device when the command from the host read is cleared from the command queue of the particular NAND device. A method comprising:

13. 12. The method of claim 11, further comprising: determining that the current workload for the particular NAND device of the plurality of NAND devices is the random write workload if the counter value associated with the command queue of the particular NAND device is zero.

14. 12. The method of claim 11, further comprising determining that the host read is pending for the particular NAND device if the counter value associated with the command queue for the particular NAND device is non-zero.

Images