Mitigating slow read interference in the memory subsystem
By identifying the end-of-read operation of the memory device and issuing a voltage discharge command, the problem of slow read interference in the memory subsystem is solved, thereby improving the performance and data reliability of the memory subsystem.
Patent Information
- Application Number
- CN202210408754.5
- Authority / Receiving Office
- CN · China
- Patent Type
- Patents(China)
- Current Assignee / Owner
- Priority Date
- 2021-04-20
- Filing Date
- 2022-04-19
- Publication Date
- 2026-11-17
- Estimated Expiration
- 2042-04-19
AI Technical Summary
The existing memory subsystem suffers from slow read interference, which leads to increased data error rate and performance degradation. Existing solutions, such as regularly intervald voltage discharge commands, may further increase the error rate or reduce performance.
By identifying the end-of-run operation of the memory device and issuing a voltage discharge command after the operation, unnecessary voltage discharges are reduced, and voltage discharge is performed only on the block associated with the end-of-run operation when it is truly necessary, thus mitigating slow read interference.
It effectively reduces the impact of slow read interference on the memory subsystem, lowers the data error rate, and improves the performance of the memory subsystem.
Smart Images

Figure CN115223608B_ABST
Abstract
Description
Technical Field
[0001] The embodiments of this disclosure generally relate to memory subsystems, and more specifically, to mitigating slow read interference in memory subsystems. Background Technology
[0002] The memory subsystem may include one or more memory devices for storing data. Memory devices may be, for example, non-volatile memory devices and volatile memory devices. Generally, a host system may utilize the memory subsystem to store data at the memory devices and retrieve data from the memory devices. Summary of the Invention
[0003] In one aspect, this disclosure provides a system comprising: a memory device; and a processing means operably coupled to the memory device to perform operations including: receiving a read request to perform a read operation on a block of the memory device; determining whether an entry corresponding to the block is stored in a data structure associated with the memory device; in response to the entry being stored in the data structure, incrementing a counter associated with the block to track the number of read operations performed on the block of the memory device; resetting a timer associated with the block to an initial value, wherein the timer tracks a period of time elapsed since the read operation on the block of the memory device was performed; determining that the counter and the timer satisfy a first criterion; and in response to determining that the counter and the timer satisfy the first criterion, removing the entry corresponding to the block from the data structure associated with the memory device.
[0004] In another aspect, this disclosure further provides a method comprising: receiving a read request to perform a read operation on a block of a memory device; determining whether an entry corresponding to the block is stored in a data structure associated with the memory device; in response to the entry being stored in the data structure, incrementing a counter associated with the block to track the number of read operations performed on the block of the memory device; resetting a timer associated with the block to an initial value, wherein the timer tracks a period of time elapsed since the read operation on the block of the memory device was performed; determining that the counter and the timer satisfy a first criterion; and in response to determining that the counter and the timer satisfy the first criterion, removing the entry corresponding to the block from the data structure associated with the memory device.
[0005] In another aspect, this disclosure further provides a non-transitory computer-readable storage medium including instructions that, when executed by a processing device, cause the processing device to perform operations including: receiving a series of read operation requests to perform read operations on a block of a memory device; identifying the end of a read from the series of read operation requests; and issuing a voltage discharge command to the block in response to identifying the end of a read from the series of read operation requests. Attached Figure Description
[0006] This disclosure will be more fully understood from the detailed description given below and the accompanying drawings of various embodiments thereof. However, the drawings should not be construed as limiting this disclosure to the specific embodiments, but are for explanation and understanding only.
[0007] Figure 1 This describes an example computing system including a memory subsystem according to some embodiments of the present disclosure.
[0008] Figure 2 The diagram illustrates the impact of slow read interference on the pass voltage of memory cells and the effect of issuing voltage discharge commands on memory cells.
[0009] Figure 3 This describes an instance data structure containing entries for block addresses, counters, and timers associated with blocks, according to some embodiments of this disclosure.
[0010] Figure 4 This is a flowchart of an example method 400 for mitigating slow read interference in a memory subsystem according to some embodiments of the present disclosure.
[0011] Figure 5 This is a flowchart of an example method 500 for mitigating slow read interference in a memory subsystem according to some embodiments of the present disclosure.
[0012] Figure 6 This is a flowchart of an example method 600 for mitigating slow read interference in a memory subsystem according to some embodiments of the present disclosure.
[0013] Figure 7 This is a block diagram of an example computer system in which embodiments of this disclosure may be operated. Detailed Implementation
[0014] Various aspects of this disclosure relate to mitigating slow read interference in a memory subsystem. The memory subsystem may be a storage device, a memory module, or a combination of a storage device and a memory module. The following is combined with… Figure 1Describe examples of storage devices and memory modules. Typically, a host system may utilize a memory subsystem, which includes one or more components, such as memory devices for storing data. The host system can provide data to be stored in the memory subsystem and can request to retrieve data from the memory subsystem.
[0015] The memory subsystem may include high-density non-volatile memory devices, where data is expected to be retained when no power is supplied to the memory devices. An example of a non-volatile memory device is a NAND flash memory device. The following section combines... Figure 1 Other examples of non-volatile memory devices are described. A non-volatile memory device is a package of one or more dies. Each die may consist of one or more planes. For some types of non-volatile memory devices (e.g., NAND devices), each plane consists of a set of physical blocks. Each block consists of a set of pages. Each page consists of a set of memory cells (“cells”). A cell is an electronic circuit that stores information. Depending on the cell type, a cell may store one or more bits of binary information and has various logical states associated with the stored bits. Logical states may be represented as binary values, such as “0” and “1”, or combinations of such values.
[0016] Memory devices can be composed of bits arranged in a two-dimensional grid. Memory cells are etched onto a silicon wafer in the form of column (hereinafter also referred to as bit lines) and row (hereinafter also referred to as word lines) arrays. A word line can refer to one or more rows of memory cells in a memory device used in conjunction with one or more bit lines to generate the address of each memory cell. The intersection of bit lines and word lines constitutes the address of a memory cell. Hereinafter, a block refers to a unit in a memory device used to store data and may contain groups of memory cells, groups of word lines, word lines, or individual memory cells. One or more blocks can be grouped together to form planes of a memory device to allow concurrent operation on each plane. A memory device may include circuitry for performing concurrent memory page accesses on two or more memory planes. For example, a memory device may include corresponding access line driver circuitry and power supply circuitry for each plane of the memory device to facilitate concurrent access to pages on two or more memory planes containing different page types.
[0017] Data operations can be performed by the memory subsystem. Data operations can be host-initiated. For example, the host system can initiate data operations (e.g., write, read, erase, etc.) against the memory subsystem. The host system can send access requests (e.g., write commands, read commands) to the memory subsystem to, for example, store data on and read data from memory devices at the memory subsystem. The data to be read or written, as specified by the host request, is referred to hereinafter as "host data". The host request may contain logical address information (e.g., logical block address (LBA), namespace) for the host data, which is the location that the host system associates with the host data. The logical address information may be part of the metadata for the host data. The metadata may also include error handling (e.g., ECC codewords, parity check codes), data versioning (e.g., timeliness for distinguishing written data), a validity bitmap (whose LBA or logical transfer unit contains valid data), etc.
[0018] Each memory cell in the memory device has an associated threshold voltage. A memory cell can be programmed by applying a specific voltage to it, which causes charge to be retained within the cell. A read voltage higher than the threshold voltage of the memory cell is applied to read the cell. Furthermore, to read a memory cell, a pass-through voltage, having a voltage higher than the threshold voltage, is applied to adjacent and nearby memory cells that are not being read.
[0019] When reading memory cells, nearby or adjacent memory cells may experience events known as read disturbances. Conventional read disturbances arise from the rapid, sequential reading of a memory cell without any erase operation, causing other nearby memory cells to change over time (e.g., be programmed). If too many read operations are performed on a memory cell, data stored in adjacent memory cells may be corrupted or improperly stored, leading to a higher error rate in the stored data. Conventional read disturbances may also be caused by increased use of error detection and correction operations (e.g., error control operations) for subsequent operations performed on memory cells (e.g., reads and / or writes). Increased use of error control operations can degrade the performance of conventional memory subsystems. Furthermore, as the error rate of a memory cell or block continues to increase, it may even exceed the error correction capabilities of the memory subsystem, resulting in irreparable data loss. Moreover, because more resources of the memory subsystem are used for error control operations, fewer resources are available for other read or write operations.
[0020] The error rate associated with data stored at a block can be increased by conventional read interference. Therefore, after performing a threshold number of read operations on the block, the memory subsystem may perform a data integrity check (also referred to herein as a "scan") to verify that the data stored at the block does not contain any errors. During the data integrity check, one or more reliability statistics are determined for the data stored at the block. One example of a reliability statistic is the raw bit error rate (RBER). RBER corresponds to the number of bit errors experienced by the data stored at the block per unit time.
[0021] The effect of a certain time interval between two consecutive read operations on a memory cell is known as slow read interference. During a read operation on a memory cell, nearby and adjacent memory cells have a higher pass-through voltage. Once a read operation is performed on a memory cell, nearby and adjacent memory cells slowly begin to discharge voltage. However, nearby and adjacent cells may take a long time to reach ground voltage, requiring software programming operations and thus degrading the performance of the memory subsystem. Although the memory subsystem can perform scans to detect errors in the data stored at the block, there is currently no way to reduce or eliminate the effects of slow read interference on the block. One possible solution when a read operation is performed on the block is to issue a voltage discharge command. The voltage discharge command brings nearby and adjacent memory cells to ground voltage (e.g., zero voltage). However, this may leave the cells in a steady state where electrons are distributed closer to the memory cell gate rather than uniformly distributed throughout the entire interior of the memory cell, thereby increasing the error rate associated with the data stored on the cell. Furthermore, this increases the time spent performing a read operation on the block because an additional command must be executed, thereby degrading the performance of the memory subsystem. Another possible solution is to issue individual voltage discharge commands separate from the read operation. Since it's unknown which block is causing the slow read interference error, voltage discharge commands can be issued at regular intervals. However, as explained above, voltage discharge commands may leave the memory cell in a steady state, where electrons are distributed closer to the memory cell gate rather than uniformly throughout the entire memory cell. The more voltage discharge commands are executed, the more the cell remains in a steady state, which increases the error rate associated with the data stored on the cell.
[0022] The present disclosure addresses the above and other shortcomings by identifying the last read in a sequence of read operations and issuing a voltage discharge command to the block of the memory device associated with the last read, thereby mitigating slow read interference in the memory subsystem. The last read is the last read operation performed on a block within a certain time period. Identifying the last read determines the read operation most likely to induce slow read interference errors, allowing a voltage discharge command to be issued to the block associated with the identified last read. As explained above, issuing a voltage discharge command while performing a read operation on a block leads to an increased error rate and reduced performance. Furthermore, issuing voltage discharge commands at regular intervals may also increase the error rate. Therefore, it is advantageous to be able to identify the last read and subsequently issue a voltage discharge command only on the block associated with the last read, thereby minimizing the number of issued voltage discharge commands and precisely identifying the specific block causing the slow read interference error. In some embodiments, to identify the last read, the memory subsystem determines the least frequently used block by maintaining a counter to track the number of read operations performed on blocks of the memory device and maintaining a timer to track the elapsed time period since the read operation on the block was performed. Each time a read operation is performed on a block of the memory device, a counter is incremented by a certain number (e.g., incremented by 1), thereby keeping track of the number of read operations performed on the block. Each time a read operation is performed on the block, a timer counts down from an initial value (e.g., 10 ms), thereby keeping track of the time period elapsed between consecutive read operations. Determining that the counter is, for example, 0 (i.e., no read operation has been performed on the block) and the timer has counted down from, for example, an initial value of 10 ms to 0 ms (i.e., a time period of 10 ms has elapsed since a read operation was performed on the block) identifies the last read, as this last read is the last read operation performed on the block within a certain time period. Since the block has been identified as the last read, a voltage discharge command can be issued on the block.
[0023] The advantages of this disclosure include, but are not limited to, performance increases. Identifying the end of a read and then issuing a voltage discharge command on the block associated with said end read mitigates the effects of slow read interference (i.e., performance degradation of the memory subsystem). Furthermore, by being able to issue the voltage discharge command for the precise read operation causing the slow read interference error, it does not require causing further performance degradation, as explained above. In fact, the voltage discharge command can be issued only on the block associated with the end read, thereby improving the performance of the memory subsystem.
[0024] Figure 1This description describes an example 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 volatile memory devices (e.g., memory device 140), one or more non-volatile memory devices (e.g., memory device 130), or a combination of such devices.
[0025] The memory subsystem 110 may be a storage device, a memory module, or a combination 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 memory (UFS) drives, secure digital cards (SD cards), and hard disk drives (HDDs). Examples of memory modules include dual in-line memory modules (DIMMs), small form factor DIMMs (SO-DIMMs), and various types of non-volatile dual in-line memory modules (NVDIMMs).
[0026] The computing system 100 may be a computing device, such as a desktop computer, laptop computer, web server, mobile device, vehicle (e.g., airplane, drone, train, car or other means of transport), device with Internet of Things (IoT) capabilities, embedded computer (e.g., embedded computer contained in a vehicle, industrial equipment or networked commercial device), or such computing device containing memory and processing devices.
[0027] The computing system 100 may include a host system 120 coupled to one or more memory subsystems 110. In some embodiments, the host system 120 is coupled to multiple memory subsystems 110 of different types. Figure 1 This describes an example of a host system 120 coupled to a memory subsystem 110. As used herein, “coupled to” or “coupled with” generally refers to a connection between components, which can be an indirect communication connection or a direct communication connection (e.g., without an intermediary component), whether wired or wireless, including connections such as electrical connections, optical connections, magnetic connections, etc.
[0028] Host system 120 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). Host system 120 uses memory subsystem 110 to, for example, write data to memory subsystem 110 and read data from memory subsystem 110.
[0029] Host system 120 can be coupled to memory subsystem 110 via a physical host interface. Examples of physical host interfaces include, but are not limited to, Serial Advanced Technology Attachment (SATA) interfaces, Peripheral Component Interconnect High Speed (PCIe) interfaces, Universal Serial Bus (USB) interfaces, Fibre Channel, Serial Attached SCSI (SAS), Dual Data Rate (DDR) memory bus, Small Computer System Interface (SCSI), Dual In-line Memory Module (DIMM) interfaces (e.g., DIMM sockets supporting Dual Data Rate (DDR)). The physical host interface can be used to transfer data between host system 120 and memory subsystem 110. When memory subsystem 110 is coupled to host system 120 via a physical host interface (e.g., a PCIe bus), host system 120 can also utilize an NVM High Speed (NVMe) interface to access components (e.g., memory device 130). The physical host interface provides an interface for transferring control, address, data, and other signals between memory subsystem 110 and host system 120. Figure 1 The memory subsystem 110 is described as an example. In general, the host system 120 can access multiple memory subsystems through the same communication connection, multiple separate communication connections, and / or a combination of communication connections.
[0030] Memory devices 130 and 140 may comprise any combination of different types of non-volatile memory devices and / or volatile memory devices. Volatile memory devices (e.g., memory device 140) may be, but are not limited to, random access memory (RAM), such as dynamic random access memory (DRAM) and synchronous dynamic random access memory (SDRAM).
[0031] Some examples of non-volatile memory devices (e.g., memory device 130) include NAND flash memory and in-place write memory, such as three-dimensional crosspoint (“3D crosspoint”) memory devices, which are crosspoint arrays of non-volatile memory cells. The crosspoint array of non-volatile memory cells can perform bit storage based on changes in volume resistance in conjunction with a stackable cross-grid data access array. Furthermore, compared to many flash-based memories, crosspoint non-volatile memory can perform in-place write operations, where non-volatile memory cells can be programmed without pre-erasing them. NAND flash memory includes, for example, two-dimensional NAND (2D NAND) and three-dimensional NAND (3D NAND).
[0032] Each of the memory devices 130 may include one or more arrays of memory cells. One type of memory cell, such as a single-level cell (SLC), may store one bit per cell. Other types of memory cells, such as multi-level cell (MLC), three-level cell (TLC), four-level cell (QLC), and five-level cell (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, PLC, 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. Memory cells in the memory device 130 may be grouped into pages, which may refer to logical cells of the memory device used for storing data. For some types of memory (e.g., NAND), pages may be grouped to form blocks.
[0033] While a 3D cross-point array of non-volatile memory cells and a non-volatile memory component of NAND flash memory (e.g., 2D NAND, 3D NAND) are described, the memory device 130 may be based on any other type of non-volatile memory, such as read-only memory (ROM), phase-change memory (PCM), select memory, other chalcogenide-based memory, ferroelectric transistor random access memory (FeTRAM), ferroelectric random access memory (FeRAM), magnetic random access memory (MRAM), spin-transfer torque (STT)-MRAM, conductive bridged RAM (CBRAM), resistive random access memory (RRAM), oxide-based RRAM (OxRAM), NOR flash memory, or electrically erasable programmable read-only memory (EEPROM).
[0034] The memory subsystem controller 115 (or, for simplicity, controller 115) can communicate with the memory device 130 to perform operations, such as reading data, writing data, or erasing data at the memory device 130, and other such operations. The memory subsystem controller 115 may include hardware, such as one or more integrated circuits and / or discrete components, buffer memories, or combinations thereof. The hardware may include a digital circuit system having dedicated (i.e., hard-decoded) logic that performs the operations described herein. The memory subsystem controller 115 may be a microcontroller, a dedicated logic circuit system (e.g., a field-programmable gate array (FPGA), an application-specific integrated circuit (ASIC), etc.), or other suitable processor.
[0035] The memory subsystem controller 115 may include a processing means comprising one or more processors (e.g., processor 117) configured to execute instructions stored in local memory 119. In the illustrated example, the local memory 119 of the memory subsystem controller 115 includes embedded memory configured to store instructions for executing various processes, operations, logic flows, and routines that control the operation of the memory subsystem 110, including handling communication between the memory subsystem 110 and the host system 120.
[0036] In some embodiments, local memory 119 may include memory registers storing memory pointers, retrieved data, etc. Local memory 119 may also include read-only memory (ROM) for storing microcode. Although... Figure 1 The instance memory subsystem 110 is described as including a memory subsystem controller 115, but in another embodiment of this disclosure, the memory subsystem 110 does not include a memory subsystem controller 115 and may instead rely on external control (e.g., provided by an external host or by a processor or controller separate from the memory subsystem).
[0037] In general, the memory subsystem controller 115 can receive commands or operations from the host system 120 and can translate these commands or operations into instructions or appropriate commands to enable desired access to the memory device 130. The memory subsystem controller 115 may handle other operations such as wear leveling, unused cell collection, error detection and error correction (ECC) operations, encryption, caching, and address translation between logical addresses (e.g., logical block addresses, namespaces) and physical addresses (e.g., physical block addresses) associated with the memory device 130. The memory subsystem controller 115 may also include a host interface circuitry for communicating with the host system 120 via a physical host interface. The host interface circuitry can translate commands received from the host system into command instructions to access the memory device 130, and translate responses associated with the memory device 130 into information for the host system 120.
[0038] The memory subsystem 110 may also include additional circuitry or components not described. In some embodiments, the memory subsystem 110 may include a cache or buffer (e.g., DRAM) and an address circuitry (e.g., row decoder and column decoder) that can receive and decode addresses from the memory subsystem controller 115 to access the memory device 130.
[0039] In some embodiments, memory device 130 includes a local media controller 135 that operates in conjunction with a 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 subsystem 110 is a managed memory device, which is the original memory device 130 having on-die control logic (e.g., local media controller 135) and a controller (e.g., memory subsystem controller 115) for media management within the same memory device package. An example of a managed memory device is a managed NAND (MNAND) device.
[0040] Memory subsystem 110 includes an end-of-read identification component 113, which can mitigate slow read interference errors in memory subsystem 110 by identifying an end-of-read and issuing a voltage discharge command to the block associated with the end-of-read. In some embodiments, memory subsystem controller 115 includes at least a portion of end-of-read identification component 113. In some embodiments, end-of-read identification component 113 is part of memory subsystem 110, an application, or an operating system. In other embodiments, local media controller 135 includes at least a portion of end-of-read identification component 113 and is configured to perform the functions described herein.
[0041] End-of-read identifier component 113 can receive a read request to perform a read operation on a block of memory device 130. Upon receiving the read request, end-of-read identifier component 113 can determine whether an entry corresponding to the block is stored in a data structure associated with the block (e.g., stored in local memory 119). In one embodiment, the data structure may be a table, and the entry may contain the block address corresponding to the block. End-of-read identifier component 113 can also store a counter and a timer in the entries of the data structure. Whenever a read operation is performed on the corresponding block, end-of-read identifier component 113 can increment the counter by an amount (e.g., increment by 1). End-of-read identifier component 113 can also start a timer associated with the block at an initial value (e.g., 10 ms) and count down. When the timer reaches a final value (e.g., 0), end-of-read identifier component 113 can decrement the counter by an amount (e.g., decrement by 1). When the corresponding values of the counter and timer both satisfy a certain criterion (e.g., both are 0), the end-of-read flag component 113 can remove the entry corresponding to the block from the data structure because the block is the least frequently used block in terms of read operations performed on it. As described above, the least frequently used block is the block associated with end-of-read (e.g., read operations that generate slow read interference errors). Therefore, the end-of-read flag component 113 can issue a voltage discharge command to the block, thereby bringing the block to ground voltage and mitigating slow read interference. Further details regarding the operation of the end-of-read flag component 113 are described below.
[0042] Figure 2 This diagram illustrates the impact of slow read interference on the voltage of a memory cell and the effect of issuing a voltage discharge command on the voltage of the memory cell. As described above, slow read interference occurs when a certain period of time elapses between two consecutive read operations performed on a memory cell. During the read operation on the memory cell, nearby and adjacent memory cells have a higher pass-through voltage. Once the read operation on the memory cell is performed, the nearby and adjacent memory cells slowly begin to discharge voltage. However, the nearby and adjacent cells may take a long time to reach ground voltage, thus requiring software programming operations and therefore causing a degradation in the performance of the memory subsystem. For example, Figure 2 This describes nearby and / or adjacent memory cells with a 9V pass-through voltage. Once a read operation is performed, the pass-through voltage of the nearby and / or adjacent memory cells naturally decays. For example... Figure 2The description indicates that the natural decay rate of the shoot-through voltage is gradual, then slows significantly towards the end, requiring (e.g.) 1000 seconds to reach ground voltage (e.g., 0 V). In contrast, when a voltage discharge command is issued to a block containing the nearby and / or adjacent memory cells, the shoot-through voltage can reach ground voltage within a shorter time period (e.g., 1 second). Figure 1 As described, the end-of-read component 113 can identify the end of a read, i.e., a block read operation for which no other read operations will occur within a certain time period thereafter. The end-of-read component 113 can then issue a voltage discharge command to the block associated with the end-of-read. Further details regarding identifying the end of a read and issuing the voltage discharge command are described below.
[0043] Figure 3 This section describes example data structures containing entries for block addresses, counters, and timers associated with blocks, according to some embodiments of this disclosure. For example, in... Figure 1 As described in more detail below, the end-read identifier component 113 can store entries corresponding to blocks in a data structure. In one embodiment, an entry can be a block address, counter, or timer associated with a block. In one embodiment, the data structure can be a table. The data structure can be stored in memory devices 130 and / or 140. In one embodiment, the data structure can hold as many entries as the memory devices 130 and / or 140 have in terms of capacity and resources. In an illustrative example, in Figure 3 At block address 107, the counter and timer associated with the entry both have a value of 0. As described below, when the counter and timer reach, for example, their final value of 0, the entry associated with the counter and timer is removed from the data structure. Then, a voltage discharge command can be issued to the block corresponding to the block address associated with the entry in the data structure, as described below regarding... Figure 4 and Figure 5 To describe in more detail.
[0044] Figure 4 This is a flowchart of an example method 400 for mitigating slow read interference in a memory subsystem according to some embodiments of the present disclosure. Method 400 may be executed by processing logic, which may include hardware (e.g., processing device, circuit system, dedicated logic, programmable logic, microcode, device hardware, integrated circuit, etc.), software (e.g., instructions that run or execute on the processing device), or a combination thereof. In some embodiments, method 400 is performed by… Figure 1The end of the read identifier component 113 is executed. Although shown in a specific order or sequence, the order of the processes may be modified unless otherwise specified. Therefore, the illustrated embodiments should be understood as examples only, and the illustrated processes may be executed in different orders, and some processes may be executed in parallel. In addition, one or more processes may be omitted in various embodiments. Therefore, not all processes are required in every embodiment. Other process flows are also possible.
[0045] At operation 410, the processing logic receives a read request to perform a read operation on a block of the memory device. In an illustrative example, this can be done from the host system (e.g., Figure 1 The host system 120 described herein receives a read request. The data to be read, as specified in the read request, is referred to hereinafter as "host data". The read request may contain logical address information (e.g., logical block address (LBA), namespace) for the host data, which is the location that the host system associates with the host data. The logical address information (e.g., LBA, namespace) may be part of the metadata for the host data. The metadata may also include error handling (e.g., ECC codeword, parity check), data versioning (e.g., timeliness for distinguishing written data), a validity bitmap (whose LBA or logical transfer unit contains valid data), etc.
[0046] At operation 415, the processing logic determines whether the entry corresponding to the block is stored in a data structure. In the illustrative example, the data structure could be... Figure 3 The data structure (i.e., table) described herein. In an illustrative example, determining whether an entry corresponding to a block is stored in the data structure includes decoding the physical address associated with the block to which a read operation is to be performed and looking up the virtual block address in the data structure. In an illustrative example, the entry may contain the block address of the block. The entry may also contain counters and timers associated with the block. In an illustrative example, if the processing logic determines that an entry corresponding to a block is not stored on the data structure and the data structure is currently complete (i.e., there is not enough space to add an additional entry), the processing logic may remove an entry corresponding to another block from the data structure and create the entry corresponding to the block. The processing logic may identify an entry corresponding to another block from the data structure by comparing the counters associated with each entry in the data structure and determining the counter with the highest value (i.e., the block associated with the highest number of reads). The processing logic may remove the entry associated with the determined counter with the highest value. Removing the entry may involve replacing the entry with an entry corresponding to the block that is not stored on the data structure. The data structure may be stored in a memory device (e.g., Figure 1 On the memory devices 130 and / or 140.
[0047] At operation 420, the processing logic increments a counter associated with the block to track the number of read operations performed on the block. In an illustrative example, the processing logic stores the counter in an entry in a data structure corresponding to the block via a memory device. In an illustrative example, the counter has an initial value of 0. In an illustrative example, the initial value is not a set value and can change at any time. The processing logic increments the counter by adding a value of 1 to the current value of the counter each time a read operation is performed on the block of the memory device.
[0048] At operation 425, the processing logic resets the timer associated with the block to its initial value. In an illustrative example, the processing logic stores the timer in an entry in a data structure corresponding to the block via a memory device. The timer tracks the elapsed time since a read operation on the block of the memory device was performed. For example, the initial value of the timer may be set to 10 ms. In an illustrative example, the initial value is not a set value and can be changed at any time. The timer may count down from the initial value to a final value, such as 0 ms. In an illustrative example, the processing logic determines whether the timer has reached its final value. In response to determining that the timer has reached its final value, the processing logic decrements a counter by a limit. The limit may be 1.
[0049] At operation 430, the processing logic determines that the counter and timer satisfy the first criterion. In an illustrative example, determining that the counter and timer satisfy the first criterion includes determining that both the counter and timer have reached their final values. In an illustrative example, the final values of both the counter and timer are 0. In an illustrative example, the final values of the counter and timer can be different numbers; for example, the final value of the counter can be 1, and the final value of the timer can be 0. In an illustrative example, the final value is not a set value and can change at any time.
[0050] At operation 435, the processing logic removes an entry corresponding to a block from a data structure associated with the memory device. In some embodiments, removing an entry corresponding to a block from the data structure includes determining that a counter and a timer satisfy a first criterion. In response to determining that the counter and timer satisfy the first criterion, the processing logic issues a voltage discharge command to the block. The voltage discharge command can bring the block to ground voltage, i.e., 0 V. In some embodiments, removing an entry corresponding to a block from the data structure includes determining that a counter satisfies a second criterion. Determining that a counter satisfies the second criterion may include identifying a counter with the highest value (i.e., the block associated with the highest number of reads).
[0051] Figure 5This is a flowchart of an example method 500 for mitigating slow read interference in a memory subsystem according to some embodiments of the present disclosure. Method 500 may be executed by processing logic, which may include hardware (e.g., processing device, circuit system, dedicated logic, programmable logic, microcode, device hardware, integrated circuit, etc.), software (e.g., instructions that run or execute on the processing device), or a combination thereof. In some embodiments, method 500 is performed by… Figure 1 The end of the read identifier component 113 is executed. Although shown in a specific order or sequence, the order of the processes may be modified unless otherwise specified. Therefore, the illustrated embodiments should be understood as examples only, and the illustrated processes may be executed in different orders, and some processes may be executed in parallel. In addition, one or more processes may be omitted in various embodiments. Therefore, not all processes are required in every embodiment. Other process flows are also possible.
[0052] At operation 510, the processing logic receives a read request to perform a read operation on a block of the memory device. In an illustrative example, this can be done from the host system (e.g., Figure 1 The host system 120 described herein receives a read request. The data to be read, as specified in the read request, is referred to hereinafter as "host data". The read request may contain logical address information (e.g., logical block address (LBA), namespace) for the host data, which is the location that the host system associates with the host data. The logical address information (e.g., LBA, namespace) may be part of the metadata for the host data. The metadata may also include error handling (e.g., ECC codeword, parity check), data versioning (e.g., timeliness for distinguishing written data), a validity bitmap (whose LBA or logical transfer unit contains valid data), etc.
[0053] At operation 515, the processing logic determines whether the entry corresponding to the block is stored in a data structure. In the illustrative example, the data structure could be... Figure 3The data structure (i.e., table) described herein. In an illustrative example, determining whether an entry corresponding to a block is stored in the data structure includes decoding the physical address associated with the block to which a read operation is to be performed and looking up the virtual block address in the data structure. In an illustrative example, the entry may contain the block address of the block. The entry may also contain counters and timers associated with the block. In an illustrative example, if the processing logic determines that an entry corresponding to a block is not stored on the data structure and the data structure is currently complete (i.e., there is not enough space to add an additional entry), the processing logic may remove an entry corresponding to another block from the data structure and create the entry corresponding to the block. The processing logic may identify an entry corresponding to another block from the data structure by comparing the counters associated with each entry in the data structure (described in more detail below at operation 520) and determining the counter with the highest value (i.e., the block associated with the highest number of reads). The processing logic may remove the entry associated with the determined counter with the highest value. Removing the entry may involve replacing the entry with an entry corresponding to the block that is not stored on the data structure. The data structure may be stored in a memory device (e.g., Figure 1 On the memory devices 130 and / or 140.
[0054] At operation 520, the processing logic stores the counter and timer in entries in the data structure corresponding to the block. In an illustrative example, the data structure could be... Figure 3 The data structure described herein (i.e., a table). Counters and timers can be stored in the same entry at the block address of a memory block. The data structure can be stored in a memory device (e.g., Figure 1 On the memory devices 130 and / or 140.
[0055] At operation 525, the processing logic increments a counter associated with the block to track the number of read operations performed on the block. In an illustrative example, the processing logic stores the counter in an entry in a data structure corresponding to the block via a memory device. For example, the counter has an initial value of 0. In this illustrative example, the initial value is not a set value and can change at any time. The processing logic increments the counter by adding a value of 1 to the current value of the counter each time a read operation is performed on the block of the memory device.
[0056] At operation 530, the processing logic resets the timer associated with the block to its initial value. In an illustrative example, the processing logic stores the timer in an entry in a data structure corresponding to the block via a memory device. The timer tracks the elapsed time since a read operation was performed on the block of the memory device. In an illustrative example, the initial value of the timer may be set to 10 ms. The initial value may be any value other than a set value and may change at any time.
[0057] At operation 535, the processing logic counts down a timer from its initial value to its final value. In an illustrative example, the timer may count down from its initial value to its final value, for example, 0 ms. In an illustrative example, the final value is not a set value and may change at any time. The processing logic determines whether the timer has reached its final value. In response to determining that the timer has reached its final value, the processing logic decrements a counter by a threshold. The threshold may be 1 or any other value.
[0058] At operation 540, the processing logic determines whether the timer has reached its final value. In an illustrative example, the processing logic can determine whether the timer has reached its final value by checking the timer's value in an entry stored in a data structure. The final value may, for example, be 0 ms.
[0059] At operation 545, in response to determining that the timer has reached its final value, the processing logic decrements the counter. For example, the processing logic may reduce the value of the counter by, say, 1.
[0060] At operation 550, if the processing logic determines that the timer has not reached its final value, then the processing logic determines whether the counter and the timer satisfy the first criterion. In an illustrative example, determining that the counter and the timer satisfy the first criterion includes determining that both the counter and the timer have reached their final values. In an illustrative example, the final values of both the counter and the timer are 0. In an illustrative example, the final values of the counter and the timer can be different numbers; for example, the final value of the counter can be 1, and the final value of the timer can be 0.
[0061] At operation 565, if the processing logic determines that the counter and timer do not meet the first criterion, the processing logic then determines whether the counter meets the second criterion. Determining that the counter meets the second criterion may include identifying the counter with the highest value (i.e., the block associated with the highest number of reads).
[0062] At operation 570, in response to determining that the counter meets the second criterion, the processing logic removes the entry corresponding to the block from the data structure.
[0063] At operation 555, if the processing logic determines that the counter and timer meet the first criterion, the processing logic removes the entry corresponding to the block from the data structure.
[0064] At operation 560, in response to operation 555, the processing logic issues a voltage discharge command to the block. The voltage discharge command causes the block to reach ground voltage, i.e., 0 V.
[0065] Figure 6This is a flowchart of an example method 600 for mitigating slow read interference in a memory subsystem according to some embodiments of the present disclosure. Method 600 may be executed by processing logic, which may include hardware (e.g., processing device, circuit system, dedicated logic, programmable logic, microcode, device hardware, integrated circuit, etc.), software (e.g., instructions that run or execute on the processing device), or a combination thereof. In some embodiments, method 600 is performed by… Figure 1 The end of the read identifier component 113 is executed. Although shown in a specific order or sequence, the order of the processes may be modified unless otherwise specified. Therefore, the illustrated embodiments should be understood as examples only, and the illustrated processes may be executed in different orders, and some processes may be executed in parallel. In addition, one or more processes may be omitted in various embodiments. Therefore, not all processes are required in every embodiment. Other process flows are also possible.
[0066] At operation 610, the processing logic receives a series of read operation requests to perform read operations on a block of the memory device. In an illustrative example, these requests can be received from a host system (e.g., Figure 1 The host system 120 described herein receives the series of read requests. The data to be read, specified by each of the series of read requests, is hereinafter referred to as "host data". Each of the series of read requests may contain logical address information (e.g., logical block address (LBA), namespace) for the host data, which is the location where the host system associates it with the host data. The logical address information (e.g., LBA, namespace) may be part of the metadata for the host data. The metadata may also include error handling (e.g., ECC codeword, parity check code), data versioning (e.g., timeliness for distinguishing written data), a validity bitmap (whose LBA or logical transfer unit contains valid data), etc.
[0067] At operation 615, the processing logic identifies the last read in the series of read operation requests. In an illustrative example, to identify the last read in the series of read operation requests, the processing logic determines whether the entry corresponding to the block is stored in a data structure. The data structure may be... Figure 3The data structure (i.e., table) described herein. In an illustrative example, determining whether an entry corresponding to a block is stored in the data structure includes decoding the physical address associated with the block to which each of the series of read operation requests is to be performed, and looking up the virtual block address in the block structure. In an illustrative example, the entry may contain the block address of the block. The entry may also contain counters and timers associated with the block. In an illustrative example, if the processing logic determines that an entry corresponding to a block is not stored on the data structure and the data structure is currently complete (i.e., there is not enough space to add an additional entry), the processing logic may remove an entry corresponding to another block from the data structure and create the entry corresponding to the block. The processing logic may identify an entry corresponding to another block from the data structure by comparing the counters associated with each entry in the data structure and determining the counter with the highest value (i.e., the block associated with the highest number of reads). The processing logic may remove the entry associated with the determined counter with the highest value. Removing the entry may involve replacing the entry with an entry corresponding to the block that is not stored on the data structure. The data structure may be stored in a memory device (e.g., Figure 1 On the memory devices 130 and / or 140.
[0068] Furthermore, at operation 615, the processing logic may increment a counter associated with the block to track the number of read operations performed on the block. In an illustrative example, the processing logic stores the counter in an entry in a data structure corresponding to the block via a memory device. In an illustrative example, the initial value is not a set value and can change at any time. The processing logic increments the counter by adding a value of 1 to the current value of the counter each time a read operation is performed on the block of the memory device. The processing logic may also reset a timer associated with the block to its initial value. In an illustrative example, the processing logic stores a timer in an entry in a data structure corresponding to the block via a memory device. The timer can track the elapsed time period since a read operation was performed on the block of the memory device. For example, the initial value of the timer may be set to 10 ms. In an illustrative example, the initial value is not a set value and can change at any time. The timer can count down from the initial value to a final value, such as 0 ms. In an illustrative example, the processing logic determines whether the timer has reached its final value. In response to determining that the timer has reached its final value, the processing logic decrements the counter by a predetermined amount. The limiting quantity can be 1. In an illustrative example, the processing logic determines that the counter and timer satisfy a first criterion. Determining that the counter and timer satisfy the first criterion may include determining that both the counter and timer have reached their final values. In an illustrative example, the final values of both the counter and timer are 0. In an illustrative example, the final values of the counter and timer can be different numbers; for example, the final value of the counter can be 1, and the final value of the timer can be 0. In an illustrative example, the final value is not a set value and can change at any time. The processing logic may remove an entry corresponding to the block from a data structure associated with the memory device. In an illustrative example, removing an entry corresponding to the block from the data structure includes determining that the counter satisfies a second criterion. Determining that the counter satisfies the second criterion may include identifying the counter with the highest value (i.e., the block associated with the highest number of reads).
[0069] At operation 620, the processing logic issues a voltage discharge command to a block of the memory device. In an illustrative example, issuing the voltage discharge command includes removing an entry corresponding to the block from a data structure associated with the memory device. Removing an entry corresponding to the block from the data structure may include determining that counters and timers meet a first criterion, as described at operation 615.
[0070] Figure 7 An example machine illustrating computer system 700 is described, within which a set of instructions can be executed to cause the machine to perform any one or more methods discussed herein. In some embodiments, computer system 700 may correspond to a host system (e.g., Figure 1 The host system 120 includes, is coupled to, or utilizes a memory subsystem (e.g., Figure 1 The memory subsystem 110) or can be used to perform controller operations (e.g., execute the operating system to perform operations corresponding to...). Figure 1 (The operation of reading the identifier component 113 at the end). In an alternative embodiment, the machine may connect (e.g., network) to other machines in a LAN, intranet, extranet, and / or the Internet. The machine may operate 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, with the capabilities of a server or client machine in a client-server network environment.
[0071] The machine may be a personal computer (PC), tablet PC, set-top box (STB), personal digital assistant (PDA), cellular phone, network device, server, network router, switch, or bridge, or any machine capable of (sequentially or otherwise) executing a set of instructions specifying actions to be taken by the machine. Furthermore, although a single machine has been described, the term "machine" should be understood to include any collection of machines that individually or collectively execute a set (or more) of instructions to perform any of the methods discussed herein.
[0072] The example computer system 700 includes a processing device 702, a main memory 704 (e.g., read-only memory (ROM), flash memory, dynamic random access memory (DRAM), such as synchronous DRAM (SDRAM) or Rambus DRAM (RDRAM), etc.), a static memory 706 (e.g., flash memory, static random access memory (SRAM), etc.), and a data storage system 718, which communicate with each other via a bus 730.
[0073] Processing device 702 represents one or more general-purpose processing devices, such as microprocessors, central processing units, etc. 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. Processing device 702 may also be one or more special-purpose processing devices, such as application-specific integrated circuits (ASICs), field-programmable gate arrays (FPGAs), digital signal processors (DSPs), network processors, etc. Processing device 702 is configured to execute instructions 726 for performing the operations and steps discussed herein. Computer system 700 may also include a network interface device 708 for communication via network 720.
[0074] The data storage system 718 may include a machine-readable storage medium 724 (also referred to as a computer-readable medium) storing one or more sets of instructions 726 or software embodying any one or more methods or functions described herein. The instructions 726 may also reside wholly or at least partially within main memory 704 and / or processing device 702 during execution by computer system 700, which also constitute machine-readable storage media. The machine-readable storage medium 724, the data storage system 718, and / or main memory 704 may correspond to... Figure 1 The memory subsystem 110.
[0075] In one embodiment, instruction 726 includes instructions for implementing a component corresponding to the end-read identifier (e.g., Figure 1 The end of the read identifier component 113) contains instructions for the function of the machine-readable storage medium 724. Although the machine-readable storage medium 724 is shown as a single medium in the exemplary embodiment, the term "machine-readable storage medium" should be considered to include a single medium or multiple media storing a set or more sets of instructions. The term "machine-readable storage medium" should also be considered to include any medium capable of storing or encoding a set of instructions for machine execution and causing the machine to perform any one or more methods of this disclosure. Therefore, the term "machine-readable storage medium" should be considered to include, but is not limited to, solid-state memory, optical media, and magnetic media.
[0076] Some parts of the previously described algorithms and symbolic representations of operations on data bits within computer memory have been presented. These algorithmic descriptions and representations are the means by which those skilled in the art of data processing most effectively communicate the essence of their work to others skilled in the art. Algorithms here, and generally are considered, are self-consistent sequences of operations that produce desired results. These operations are those that require physical manipulation of physical quantities. These quantities are typically, but not necessarily, in the form of electrical or magnetic signals that can be stored, combined, compared, and otherwise manipulated. Sometimes, it has proven convenient to refer to these signals primarily for general reasons as bits, values, elements, symbols, characters, items, numbers, etc.
[0077] However, it should be remembered that all these and similar terms should be associated with appropriate physical quantities and are merely convenient labels applied to those quantities. This disclosure may refer to the actions and processes of a computer system or similar electronic computing device that manipulate and transform data represented as physical (electronic) quantities in the registers and memories of the computer system into other data similarly represented as physical quantities in the computer system's memory or registers or other such information storage systems.
[0078] This disclosure also relates to apparatus for performing the operations described herein. Such apparatus may be specifically constructed for a particular purpose, or may comprise a general-purpose computer selectively activated or reconfigured by a computer program stored in a computer. Such computer programs may be stored in computer-readable storage media, such as, but not limited to, any type of disk (including floppy disks, optical disks, CD-ROMs, and magneto-optical disks), read-only memory (ROM), random access memory (RAM), EPROM, EEPROM, magnetic cards, or optical cards, or any type of media suitable for storing electronic instructions, each media coupled to a computer system bus.
[0079] The algorithms and demonstrations presented herein are not inherently related to any particular computer or other device. Various general-purpose systems can be used with the programs taught herein, or it may be proven convenient to construct more specialized devices to perform the methods. The architectures of various such systems will be presented as described below. Furthermore, this disclosure is described without reference to any particular programming language. It should be understood that the teachings of this disclosure described herein can be implemented using various programming languages.
[0080] This disclosure can be provided as a computer program product or software, which may include a machine-readable medium having instructions stored thereon that can be used to program a computer system (or other electronic device) to perform processes according to this disclosure. The machine-readable medium includes any mechanism for storing information in a machine-readable (e.g., computer-readable) form. In some embodiments, the machine-readable (e.g., computer-readable) medium includes machine-readable storage media, such as read-only memory (“ROM”), random access memory (“RAM”), disk storage media, optical storage media, flash memory components, etc.
[0081] In the foregoing description, embodiments of the present disclosure have been described with reference to specific examples. It will be apparent that various modifications can be made to the present disclosure without departing from the broader spirit and scope of the embodiments set forth in the appended claims. Therefore, the description and drawings should be viewed in an illustrative rather than restrictive sense.
Claims
1. A memory system comprising: Memory devices; as well as A processing device operatively coupled to the memory device to perform operations including: Receive a read request to perform a read operation on a block of the memory device; Determine whether the entry corresponding to the block is stored in a data structure associated with the memory device; In response to the entry being stored in the data structure, a counter associated with the block is incremented to track the number of read operations performed on the block of the memory device; The timer associated with the block is reset to its initial value, wherein the timer tracks the elapsed time since the read operation was performed on the block of the memory device; The counter and the timer are determined to satisfy a first criterion, wherein the first criterion corresponds to the respective final values of the counter and the timer, and wherein satisfying the first criterion indicates the minimum number of read operations to be performed on the block; as well as In response to determining that the counter and the timer satisfy the first criterion, a voltage discharge command is issued to the block, wherein issuing the voltage discharge command causes the block to reach the ground voltage.
2. The memory system of claim 1, wherein the counter and the timer are stored in the data structure in the entry corresponding to the block via the memory device.
3. The memory system according to claim 1, further comprising: In response to determining that the counter and the timer satisfy the first criterion, the entry corresponding to the block is removed from the data structure associated with the memory device.
4. The memory system of claim 1, wherein determining that the counter and the timer satisfy the first criterion includes determining that both the counter and the timer have reached their respective final values.
5. The memory system of claim 3, wherein removing the entry corresponding to the block from the data structure associated with the memory device is a response to determining that the counter satisfies the second criterion.
6. The memory system of claim 1, wherein the timer counts down from the initial value to the corresponding final value of the timer, and wherein the processing means performs operations further comprising: In response to determining that the timer has reached its corresponding final value, the counter is decremented by a predetermined amount.
7. The memory system of claim 1, wherein the processing means performs operations further comprising: In response to the fact that the entry corresponding to the block is not stored in the data structure, an entry corresponding to another block is removed from the data structure associated with the memory device and the entry corresponding to the block is created in the data structure.
8. A method for operating a memory system, comprising: Receive a read request to perform a read operation on a block of the memory device; The entry corresponding to the block is determined to be stored in a data structure associated with the memory device; In response to the entry being stored in the data structure, a counter associated with the block is incremented to track the number of read operations performed on the block of the memory device; The timer associated with the block is reset to its initial value, wherein the timer tracks the elapsed time since the read operation was performed on the block of the memory device; The counter and the timer are determined to satisfy a first criterion, wherein the first criterion corresponds to the respective final values of the counter and the timer, and wherein satisfying the first criterion indicates the minimum number of read operations to be performed on the block; as well as In response to determining that the counter and the timer satisfy the first criterion, a voltage discharge command is issued to the block, wherein issuing the voltage discharge command causes the block to reach the ground voltage.
9. The method of claim 8, wherein the counter and the timer are stored in the entry corresponding to the block in the data structure associated with the memory device.
10. The method of claim 8, further comprising: In response to determining that the counter and the timer satisfy the first criterion, the entry corresponding to the block is removed from the data structure associated with the memory device.
11. The method of claim 8, wherein determining that the counter and the timer satisfy the first criterion includes determining that both the counter and the timer have reached their respective final values.
12. The method of claim 10, wherein removing the entry corresponding to the block from the data structure associated with the memory device is a response to determining that the counter satisfies the second criterion.
13. The method of claim 8, wherein the timer counts down from the initial value to the corresponding final value of the timer, and wherein the counter is decremented by a predetermined amount in response to determining that the timer has reached the corresponding final value of the timer.
14. The method of claim 8, further comprising: In response to the fact that the entry corresponding to the block is not stored in the data structure, an entry corresponding to another block is removed from the data structure associated with the memory device and the entry corresponding to the block is created in the data structure.
15. A non-transitory computer-readable storage medium including instructions that, when executed by a processing means, cause the processing means to perform operations including: Receives a series of read operation requests to perform read operations on blocks of the memory device; Determine whether the entry corresponding to the block is stored in a data structure associated with the memory device; In response to the entry being stored in the data structure, a counter associated with the block is incremented to track the number of read operations performed on the block of the memory device; The timer associated with the block is reset to its initial value, wherein the timer tracks the elapsed time since a read operation was performed on the block of the memory device; Read from the end of the series of read operation requests; The final read is determined to satisfy a first criterion, wherein the first criterion corresponds to the respective final values of the counters and timers associated with the block, and wherein satisfying the first criterion indicates the minimum number of read operations to be performed on the block; as well as In response to determining that the end read satisfies the first criterion, a voltage discharge command is issued to the block, wherein issuing the voltage discharge command causes the block to reach ground voltage.
16. The non-transitory computer-readable storage medium of claim 15, wherein identifying the end read from the series of read operation requests comprises: It is determined that the counter and the timer satisfy the first criterion; as well as In response to determining that the counter and the timer satisfy the first criterion, the entry corresponding to the block is removed from the data structure associated with the memory device.
17. The non-transitory computer-readable storage medium of claim 16, wherein determining that the counter and the timer satisfy the first criterion includes determining that both the counter and the timer have reached their respective final values.
18. The non-transitory computer-readable storage medium of claim 16, wherein removing the entry corresponding to the block from the data structure associated with the memory device is a response to determining that the counter satisfies the second criterion.
19. The non-transitory computer-readable storage medium of claim 16, wherein the timer counts down from the initial value to the corresponding final value of the timer, and wherein the counter is decremented by a predetermined amount in response to determining that the timer has reached the corresponding final value of the timer.
20. The non-transitory computer-readable storage medium of claim 16, wherein the processing means performs operations further comprising: In response to the fact that the entry corresponding to the block is not stored in the data structure, an entry corresponding to another block is removed from the data structure associated with the memory device and the entry corresponding to the block is created in the data structure.
Citation Information
Patent Citations
Background deduplication of data sets in a memory
US20130326115A1
Delayed FIFO status for serial shift emulation
US5619681A
Least profitability used caching scheme
US8788758B1
Methods and systems for providing data security in data storage devices
US9530436B1
