Techniques for adjusting the granularity associated with readout interference tracking

By dynamically adjusting the granularity of the memory array and the counter tracking read commands, the data reliability problem caused by read interference in the memory system is solved, achieving efficient read interference mitigation and resource saving.

CN115705900BActive Publication Date: 2026-11-17MICRON TECHNOLOGY INC
View PDF 1 Cites 0 Cited by

Patent Information

Application Number
CN202210950322.7
Authority / Receiving Office
CN · China
Patent Type
Patents(China)
Current Assignee / Owner
Priority Date
2021-08-11
Filing Date
2022-08-09
Publication Date
2026-11-17
Estimated Expiration
2042-08-09

AI Technical Summary

Technical Problem

Existing memory systems are prone to changes in the programming logic state of memory cells during read operations, leading to data reliability issues. Furthermore, existing technologies waste resources when tracking and remedying read interference, and cannot efficiently identify areas that need remediation.

Method used

By dynamically adjusting the granularity of the memory array, using a counter to track the number of read commands, adjusting the granularity based on a baseline threshold to identify areas that need read interference remediation, and performing data rewrite operations when necessary, unnecessary resource consumption is reduced.

Benefits of technology

Effectively identify and apply read interference remediation operations to reduce resource waste and improve the data reliability and efficiency of memory systems.

✦ Generated by Eureka AI based on patent content.

Smart Images

  • Figure CN115705900B_ABST
    Figure CN115705900B_ABST
Patent Text Reader

Abstract

This application relates to techniques for adjusting the granularity associated with read interference tracking. In some instances, a memory system may receive a set of read commands from a host system, instructing the memory system to read data stored in a memory array. The memory system can track the number of executed read commands corresponding to a first portion of the memory array at a first granularity and determine whether the number of read commands meets a threshold. If the number of read commands meets the threshold, the memory system can adjust the granularity used to track the executed read commands of the first portion from the first granularity to a second granularity. For example, the memory system can increase or decrease the granularity used to track the executed read commands of the first portion. The memory system can use the tracked number of executed read commands to remedy read interference.
Need to check novelty before this filing date? Find Prior Art

Description

[0001] Cross-referencing

[0002] This patent application claims priority to U.S. Patent Application No. 17 / 399,771, filed August 11, 2021, entitled “Techniques for Adjudicating a Granularity Assaulted with Read Disturb Tracking,” which has been assigned to its assignee and is expressly incorporated herein by reference. Technical Field

[0003] The technical field relates to techniques for adjusting the granularity associated with reading interference tracking. Background Technology

[0004] Memory devices are widely used to store information in various electronic devices such as computers, user devices, cameras, and digital displays. Information is stored by programming memory cells within the memory device into various states. For example, a binary memory cell can be programmed into one of two supported states, typically corresponding to logic 1 or logic 0. In some instances, a single memory cell can support more than two possible states, any of which can be stored by the memory cell. To access the information stored by the memory device, a component can read or sense the state of one or more memory cells within the memory device. To store information, a component can write or program one or more memory cells within the memory device into corresponding states.

[0005] Various types of memory devices exist, including magnetic hard disks, random access memory (RAM), read-only memory (ROM), dynamic RAM (DRAM), synchronous dynamic RAM (SDRAM), static RAM (SRAM), ferroelectric RAM (FeRAM), magnetic RAM (MRAM), resistive RAM (RRAM), flash memory, phase-change memory (PCM), 3D crosspoint memory, NOR and NAND memory devices, and others. Memory devices can be volatile or non-volatile. Volatile memory cells (e.g., DRAM cells) can lose their programmed state over time unless periodically updated by an external power supply. Non-volatile memory cells (e.g., NAND memory cells) can maintain their programmed state for extended periods even in the absence of an external power supply. Summary of the Invention

[0006] An apparatus is described. The apparatus may include a memory device and a controller coupled to the memory device. The controller may be configured to receive a set of read commands for accessing one or more memory cells of a memory array, track the number of executed read commands corresponding to a first portion of the memory array according to a first granularity, the tracking determining, based on the number of executed read commands, whether the number of executed read commands corresponding to the first portion of the memory array meets the threshold during a first duration, and based on the determination that the number of executed read commands corresponding to the first portion of the memory array meets the threshold during the first duration, switch from the first granularity to a second granularity for tracking the number of executed read commands corresponding to the first portion of the memory array.

[0007] A non-transitory computer-readable medium storing code is described. The non-transitory computer-readable medium may contain instructions that, when executed by a processor of an electronic device, cause the electronic device to receive a set of read commands for accessing one or more memory cells of a memory array, track the number of executed read commands corresponding to a first portion of the memory array according to a first granularity, the tracking determining, based on the number of executed read commands, whether the number of executed read commands corresponding to the first portion of the memory array meets the threshold during a first duration, and based on the determination that the number of executed read commands corresponding to the first portion of the memory array meets the threshold during the first duration, switch from the first granularity to a second granularity for tracking the number of executed read commands corresponding to the first portion of the memory array.

[0008] A method is described. The method may include receiving a set of read commands for accessing one or more memory cells of a memory array; tracking the number of executed read commands corresponding to a first portion of the memory array according to a first granularity; the tracking, based on the number of executed read commands, determining whether the number of executed read commands corresponding to the first portion of the memory array meets the threshold during the first duration; and switching from the first granularity to a second granularity for tracking the number of executed read commands corresponding to the first portion of the memory array based on the determination that the number of executed read commands corresponding to the first portion of the memory array meets the threshold during the first duration. Attached Figure Description

[0009] Figure 1 An example of a system is shown that supports techniques for adjusting the granularity associated with readout interference tracking, based on examples disclosed herein.

[0010] Figure 2An example of a system is shown that supports techniques for adjusting the granularity associated with readout interference tracking, based on examples disclosed herein.

[0011] Figure 3 An example of a counter storage scheme supporting techniques for adjusting the granularity associated with read interference tracking is shown, based on examples disclosed herein.

[0012] Figure 4 An example of a process flow for adjusting the granularity associated with readout interference tracking, based on examples disclosed herein, is shown.

[0013] Figure 5 A block diagram of a memory system is shown, based on examples disclosed herein, that supports techniques for adjusting the granularity associated with read interference tracking.

[0014] Figure 6 A flowchart illustrating one or more methods for adjusting the granularity associated with readout interference tracking, based on examples disclosed herein. Detailed Implementation

[0015] A memory system coupled to a host system can receive multiple read commands from the host system over time. A read command may instruct the memory system to read one or more logic states of one or more memory cells. In some instances, repeatedly performing read operations can negatively impact memory cells. For example, during a read operation, the memory system may bias the word line of a selected memory cell to a threshold voltage, and in some instances, simultaneously bias unselected word lines near the selected word line to a relatively high voltage (e.g., above the threshold). However, repeatedly biasing unselected word lines to a relatively high voltage during a read operation can cause changes in the programmed logic state of the memory cells associated with the unselected word lines, potentially leading to data reliability issues for the memory cells. To mitigate this negative impact, the memory system can perform read interference remediation operations on one or more corresponding portions of the memory array. To perform read interference remediation operations, the memory system can implement a counter to track the number of read commands executed at each portion of the memory array. If the number of read commands executed at a portion of the memory array meets a reliability threshold, the data stored at that portion can be moved to another location to avoid data loss (e.g., to prevent bias from executed read commands from altering the programmed logic state, causing it to be misread or unreadable). However, one or more portions of the memory array may fail to meet the reliability threshold. Thus, memory and processing resources allocated to tracking counters associated with read disturbance remediation operations corresponding to these portions may be wasted, as the memory system may be tracking read disturbance remediation information for portions of the memory array that do not (or may rarely) trigger read disturbance remediation operations.

[0016] As described herein, a memory system can predict which portions of the memory array will benefit from read interference remediation operations and apply the operations to one or more predicted portions. To do this, the memory system can organize the memory array into portions according to a first granularity and employ a counter for each portion to track the number of read commands executed at each portion. In some instances, the first granularity can be relatively coarse. For example, the memory array can be divided into blocks of memory for tracking executed read commands. The memory system can, for example, periodically (or non-periodically) check the counters and determine whether the number of executed read commands associated with a portion meets a baseline threshold. The baseline threshold can be a reliability threshold divided by a period. If the number of executed read commands associated with said portion exceeds the baseline threshold, the memory system can adjust the granularity to track the number of executed read commands for said portion. That is, the memory system can organize the portions into a set of second portions according to a second granularity and can add counters such that the memory system can track the number of read commands executed at each second portion. In some instances, the second granularity can be finer than the first granularity. For example, one or more memory portions can be further divided into pages (e.g., instead of blocks).

[0017] In some instances, exceeding a baseline threshold may indicate that a portion of the memory array could benefit from read interference remediation. Thus, the memory system can apply read interference remediation to said portion. That is, the memory system can compare the number of executed read commands associated with a second portion of the set of second portions to a reliability threshold. If the number of executed read commands exceeds the reliability threshold, the memory system can test the data and rewrite the data of the second portion to a different location (e.g., if the test indicates that the quality of the data can benefit from relocation). In some instances, counters can be added, removed, or both added and removed as the tracking granularity changes (e.g., increased or decreased). For example, counters associated with one or more portions can be removed, and counters associated with the second portion can be added. If a read command is executed at a location in the memory array, the memory system can locate the counter associated with said location and increment the counter. In some instances, counters can be stored in the memory system according to a specific data organization structure (e.g., a binary tree). Using the techniques described herein, a memory system can dynamically adjust the granularity of read interference remediation tracking to support relatively granular tracking at relatively high utilization portions of the memory array (e.g., where the number of executed read commands exceeds a first threshold) and provide memory and processing savings by performing relatively low granular tracking at relatively low utilization portions of the memory array (e.g., where the number of executed read commands fails to meet a second threshold). Therefore, the memory system can effectively identify which areas of the memory array are experiencing the most read traffic and accurately apply read interference remediation operations to these areas while reducing the resources required to track read commands in other areas where read traffic is below a threshold.

[0018] refer to Figure 1 and 2 The features of this disclosure are first described in the context of systems and apparatus. (References) Figure 3 and 4 The features of this disclosure are described in the context of the counter storage scheme and processing flow. References Figure 5 and 6 These and other features of this disclosure are further shown and described in the context of device diagrams and flowcharts relating to techniques for adjusting the granularity associated with reading interference tracking.

[0019] Figure 1 An example of a system 100 is shown, which supports techniques for adjusting the granularity associated with read interference tracking, according to examples disclosed herein. System 100 includes a host system 105 coupled to a memory system 110.

[0020] The memory system 110 may be or include any device or collection of devices, wherein the device or collection of devices includes at least one memory array. For example, the memory system 110 may be or include a Universal Flash Storage (UFS) device, an Embedded Multimedia Controller (eMMC) device, a flash device, a Universal Serial Bus (USB) flash device, a Secure Digital (SD) card, a Solid State Drive (SSD), a Hard Disk Drive (HDD), a Dual In-line Memory Module (DIMM), a Small Form Factor DIMM (SO-DIMM), or a Non-Volatile DIMM (NVDIMM), and other possible options.

[0021] System 100 may be contained in 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) capability, embedded computer (e.g., embedded computer contained in a vehicle, industrial equipment or networked business device), or any other computing device containing memory and processing means.

[0022] System 100 may include a host system 105, which may be coupled to a memory system 110. In some instances, this coupling may include an interface with a host system controller 106, which may be an instance of a controller or control component configured to cause the host system 105 to perform various operations according to the examples described herein. The host system 105 may include one or more devices, and in some cases may include a processor chipset and a software stack executed via the processor chipset. For example, the host system 105 may include an application configured to communicate with the memory system 110 or devices therein. The processor chipset may include one or more cores, one or more caches (e.g., memory native to the host system 105 or included in the host system), a memory controller (e.g., an NVDIMM controller), and a storage protocol controller (e.g., a Peripheral Component Interconnect High Speed ​​(PCIe) controller, a Serial Advanced Technology Attachment (SATA) controller). The host system 105 may use the memory system 110, for example, to write data to and read data from the memory system 110. Although in Figure 1 A memory system 110 is shown, but the host system 105 can be coupled to any number of memory systems 110.

[0023] Host system 105 may be coupled to memory system 110 via at least one physical host interface. In some cases, host system 105 and memory system 110 may be configured to communicate via the physical host interface using associated protocols (e.g., to exchange or otherwise convey control, address, data, and other signals between memory system 110 and host system 105). Examples of physical host interfaces may include, but are not limited to, SATA interfaces, UFS interfaces, eMMC interfaces, PCIe interfaces, USB interfaces, Fibre Channel interfaces, Small Computer System Interface (SCSI), Serial Attached SCSI (SAS), Dual Data Rate (DDR) interfaces, DIMM interfaces (e.g., DDR-enabled DIMM sockets), Open NAND Flash Interface (ONFI), and Low Power Dual Data Rate (LPDDR) interfaces. In some instances, one or more of these interfaces may be included in host system controller 106 of host system 105 and memory system controller 115 of memory system 110, or otherwise supported between them. In some instances, host system 105 may be coupled to memory system 110 via a corresponding physical host interface of each memory device 130 included in memory system 110, or via a corresponding physical host interface of each type of memory device 130 included in memory system 110 (e.g., host system controller 106 may be coupled to memory system controller 115).

[0024] Memory system 110 may include memory system controller 115 and one or more memory devices 130. Memory device 130 may include one or more memory arrays of any type of memory cells (e.g., non-volatile memory cells, volatile memory cells, or any combination thereof). Although in Figure 1 The example shows two memory devices 130-a and 130-b, but the memory system 110 can contain any number of memory devices 130. Furthermore, if the memory system 110 contains more than one memory device 130, the different memory devices 130 within the memory system 110 can contain the same or different types of memory cells.

[0025] The memory system controller 115 may be coupled to and communicate with the host system 105 (e.g., via a physical host interface) and may be an example of a controller or control component configured to cause the memory system 110 to perform various operations as described herein. The memory system controller 115 may also be coupled to and communicate with the memory device 130 to perform operations such as reading data, writing data, erasing data, or refreshing data at the memory device 130, and other such operations, which may generally be referred to as access operations. In some cases, the memory system controller 115 may receive commands from the host system 105 and communicate with one or more memory devices 130 to execute such commands (e.g., at a memory array within the one or more memory devices 130). For example, the memory system controller 115 may receive commands or operations from the host system 105 and may translate these commands or operations into instructions or appropriate commands to achieve desired access to the memory device 130. In some cases, the memory system controller 115 may exchange data with the host system 105 and with one or more memory devices 130 (e.g., in response to a command from the host system 105 or otherwise associated with a command from said host system). For example, the memory system controller 115 may translate responses associated with the memory device 130 (e.g., data packets or other signals) into corresponding signals for the host system 105.

[0026] The memory system controller 115 may be configured for other operations associated with the memory device 130. For example, the memory system controller 115 may perform or manage operations such as wear leveling, garbage collection, error detection or error correction, encryption, caching, media management, background refresh, health monitoring, and address translation between logical addresses (e.g., logical block addresses (LBAs)) associated with commands from the host system 105 and physical addresses (e.g., physical block addresses) associated with memory cells within the memory device 130.

[0027] The memory system controller 115 may include hardware such as one or more integrated circuits or discrete components, buffer memories, or combinations thereof. The hardware may include circuitry with dedicated (e.g., hard-coded) logic to perform the operations described herein that pertain to the memory system controller 115. The memory system controller 115 may be or include a microcontroller, a dedicated logic circuitry system (e.g., a field-programmable gate array (FPGA), an application-specific integrated circuit (ASIC), a digital signal processor (DSP)), or any other suitable processor or processing circuitry system.

[0028] The memory system controller 115 may also include local memory 120. In some cases, local memory 120 may include read-only memory (ROM) or other memory capable of storing operational code (e.g., executable instructions) that can be executed by the memory system controller 115 to perform the functions belonging to the memory system controller 115 herein. In some cases, local memory 120 may additionally or alternatively include static random access memory (SRAM) or other memory available for internal storage or computation by the memory system controller 115, for example, internal storage or computation related to the functions belonging to the memory system controller 115 herein. Additionally or alternatively, local memory 120 may be used as a cache for the memory system controller 115. For example, if data is read from or written to memory device 130, then data may be stored in local memory 120, and the data may be available within local memory 120 for subsequent retrieval or manipulation (e.g., updating) by the host system 105 (e.g., with reduced latency relative to memory device 130) according to a caching strategy.

[0029] although Figure 1 An example of memory system 110 has been illustrated as including memory system controller 115, but in some cases, memory system 110 may not include memory system controller 115. For example, memory system 110 may additionally or alternatively rely on an external controller (e.g., implemented by host system 105) or one or more local controllers 135, which may be located within memory device 130 respectively, to perform the functions belonging to memory system controller 115 herein. Generally, in some cases, one or more functions belonging to memory system controller 115 herein may alternatively be performed by host system 105, local controller 135, or any combination thereof. In some cases, memory device 130 managed at least in part by memory system controller 115 may be referred to as a managed memory device. An example of a managed memory device is a managed NAND (MNAND) device.

[0030] Memory device 130 may include one or more arrays of non-volatile memory cells. For example, memory device 130 may include NAND (e.g., NAND flash) memory, ROM, phase-change memory (PCM), auto-select memory, other chalcogenide-based memories, ferroelectric random access memory (RAM) (FeRAM), magnetic RAM (MRAM), NOR (e.g., NOR flash) memory, spin-transfer torque (STT)-MRAM, conductive bridged RAM (CBRAM), resistive random access memory (RRAM), oxide-based RRAM (OxRAM), electrically erasable programmable ROM (EEPROM), or any combination thereof. Alternatively or additionally, memory device 130 may include one or more arrays of volatile memory cells. For example, memory device 130 may include RAM memory cells, such as dynamic RAM (DRAM) memory cells and synchronous DRAM (SDRAM) memory cells.

[0031] In some instances, memory device 130 may include (e.g., on the same die or within the same package) a local controller 135 that can operate on one or more memory cells of the respective memory device 130. The local controller 135 may operate in conjunction with memory system controller 115, or may perform one or more functions belonging to memory system controller 115 herein. For example, as... Figure 1 As shown, memory device 130-a may include local controller 135-a, and memory device 130-b may include local controller 135-b.

[0032] In some cases, memory device 130 may be or include a NAND device (e.g., a NAND flash device). Memory device 130 may be or include a memory die 160. For example, in some cases, memory device 130 may be a package containing one or more dies 160. In some instances, die 160 may be a piece of electronic device-grade semiconductor diced from a wafer (e.g., a silicon die diced from a silicon wafer). Each die 160 may include one or more planes 165, and each plane 165 may include a corresponding set of blocks 170, wherein each block 170 may include a corresponding set of pages 175, and each page 175 may include a set of memory cells.

[0033] In some cases, the NAND memory device 130 may include memory cells configured to each store one bit of information, which may be referred to as a single-level cell (SLC). Alternatively, the NAND memory device 130 may include memory cells configured to each store multiple bits of information; if configured to store two bits of information, it may be referred to as a multi-level cell (MLC); if configured to store three bits of information, it may be referred to as a three-level cell (TLC); if configured to store four bits of information, it may be referred to as a four-level cell (QLC), or more generally, a multi-level memory cell. Multi-level memory cells can provide greater storage density compared to SLC memory cells, but in some cases, this may involve narrower read or write margins or greater complexity for supporting circuitry.

[0034] In some cases, plane 165 may refer to a group of blocks 170, and in some cases, parallel operations may occur within different planes 165. For example, parallel operations can be performed on memory cells within different blocks 170, provided that different blocks 170 are in different planes 165. In some cases, a single block 170 may be referred to as a physical block, and virtual block 180 may refer to a group of blocks 170 in which parallel operations can occur. For example, parallel operations can be performed on blocks 170-a, 170-b, 170-c, and 170-d, respectively, within planes 165-a, 170-b, 170-c, and 170-d, and blocks 170-a, 170-b, 170-c, and 170-d may be collectively referred to as virtual block 180. In some cases, a virtual block may contain blocks 170 from different memory devices 130 (e.g., blocks in one or more planes including memory devices 130-a and 130-b). In some cases, blocks 170 within a virtual block may have the same block address within their respective planes 165 (e.g., block 170-a may be “block 0” of plane 165-a, block 170-b may be “block 0” of plane 165-b, etc.). In some cases, parallel operations in different planes 165 may be subject to one or more limitations, such as parallel operations on memory cells within different pages 175 that have the same page address within their respective planes 165 (e.g., related to command decoding, page address decoding circuitry, or other circuitry shared across planes 165).

[0035] In some cases, block 170 may contain memory cells organized in rows (page 175) and columns (e.g., strings, not shown). For example, memory cells in the same page 175 may share a common word line (e.g., coupled thereto), and memory cells in the same string may share a common digital line (which may alternatively be referred to as a bit line) (e.g., coupled thereto).

[0036] For some NAND architectures, memory cells can be read and programmed (e.g., written) at a first granularity level (e.g., at the page granularity level), but can be erased at a second granularity level (e.g., at the block granularity level). That is, page 175 may be the smallest unit of memory (e.g., a collection of memory cells) that can be independently programmed or read (e.g., simultaneously programmed or read as part of a single programming or reading operation), and block 170 may be the smallest unit of memory (e.g., a collection of memory cells) that can be independently erased (e.g., simultaneously erased as part of a single erase operation). Furthermore, in some cases, NAND memory cells may be erased before they can be rewritten with new data. Therefore, for example, in some cases, page 175 may not be updated until the entire block 170 containing page 175 has been erased.

[0037] In some cases, to update some data within block 170 while retaining other data within block 170, memory device 130 may copy the data to be retained to a new block 170 and write the updated data to one or more remaining pages of the new block 170. Memory device 130 (e.g., local controller 135) or memory system controller 115 may mark or otherwise designate data retained in the old block 170 as invalid or obsolete, and may update the logical-to-physical (L2P) mapping table to associate the logical address (e.g., LBA) of the data with the new valid block 170 instead of the old invalid block 170. In some cases, for example, considering latency or overhead, this copying and remapping may be performed instead of erasing and rewriting the entire old block 170. In some cases, one or more copies of the L2P mapping table may be stored within memory cells of memory device 130 (e.g., within one or more blocks 170 or plane 165) for use by local controller 135 or memory system controller 115 (e.g., for reference and updating).

[0038] In some cases, an L2P mapping table can be maintained, and data can be marked as valid or invalid at the page level. Page 175 may contain valid data, invalid data, or no data. Invalid data may be outdated data due to a newer or more recent version of the data being stored in a different page 175 of memory device 130. Invalid data may have previously been programmed into an invalid page 175 but may no longer be associated with a valid logical address (such as a logical address referenced by host system 105). Valid data may be the latest version of such data stored on memory device 130. Page 175 that does not contain data may be a page 175 that has never been written to or has been erased.

[0039] In some cases, the memory system controller 115 or the local controller 135 may perform operations on the memory device 130 (e.g., as part of one or more media management algorithms), such as wear leveling, background refresh, garbage collection, cleanup, block scanning, health monitoring, or other operations, or any combination thereof. For example, within the memory device 130, block 170 may have some pages 175 containing valid data and some pages 175 containing invalid data. To avoid waiting for all pages 175 in block 170 to have invalid data in order to erase and reuse block 170, an algorithm called “garbage collection” may be invoked to allow block 170 to be erased and freed up as a free block for subsequent write operations. Garbage collection may refer to a set of media management operations that include, for example, selecting block 170 containing valid and invalid data, selecting pages 175 in the block containing valid data, copying valid data from the selected pages 175 to a new location (e.g., a free page 175 in another block 170), marking data in the previously selected pages 175 as invalid, and erasing the selected block 170. Therefore, the number of erased blocks 170 can be increased, allowing more blocks 170 to be used to store subsequent data (e.g., data subsequently received from the host system 105).

[0040] System 100 may contain any number of non-transitory computer-readable media that support techniques for adjusting the granularity associated with read interference tracking. For example, host system 105, memory system controller 115, or memory device 130 may contain or otherwise access one or more non-transitory computer-readable media containing storage instructions (e.g., firmware) for performing functions belonging to host system 105, memory system controller 115, or memory device 130 herein. For example, if such instructions are executed by host system 105 (e.g., by host system controller 106), memory system controller 115, or memory device 130 (e.g., by local controller 135), such instructions may cause host system 105, memory system controller 115, or memory device 130 to perform one or more associated functions as described herein.

[0041] In some cases, memory system 110 may utilize memory system controller 115 to provide a managed memory system, which may include, for example, one or more memory arrays and associated circuitry combined with a local (e.g., on-die or in-package) controller (e.g., local controller 135). An example of a managed memory system is an MNAND system.

[0042] In some instances, memory system 110 may perform read operations to determine one or more logic states at one or more memory cells stored in the memory array included in memory device 130. In some instances, performing multiple read operations at the same location may unintentionally alter the data stored at said location. To mitigate data degradation, memory system 110 may employ read interference remediation operations on the memory array. To perform read interference remediation operations, memory system 110 may track how many times a portion of the memory array has been accessed. That is, memory system 110 may organize the memory array of memory device 130 into different portions and may store a counter for each portion indicating the number of read commands performed on said portion. If the number of executed read commands corresponding to a portion exceeds a reliability threshold, memory device 130 may rewrite the data stored at said portion to a different location (e.g., remove unintended voltage modifications caused by the executed read commands from the written data).

[0043] Some memory systems can apply read interference remedy operations to portions corresponding to a threshold data size (e.g., a minimum threshold size for reading data) of the memory array of the memory device. That is, the memory system can maintain a read counter for each physical location in the memory array (e.g., each unit of the minimum threshold size for reading data). Therefore, each portion for read interference remedy tracking can correspond to 4 kilobytes (kB) of storage at the memory array, and the memory system can use 4 bytes of storage to maintain a counter for each 4 kilobyte of storage. Thus, such counters associated with these portions can consume valuable space in the memory (e.g., up to 1 / 1024 of the memory device's capacity). Furthermore, some portions of the memory array may rarely or never reach the reliability threshold, allowing one or more counters to utilize memory resources without adding value by triggering read interference remedy operations.

[0044] Conversely, as described herein, memory system 110 can adjust the granularity of read tracking for the memory array. By dynamically adjusting the granularity, memory system 110 can support read interference mitigation while reducing memory and processing overhead associated with tracking executed read commands. In some instances, memory system 110 can organize the memory array into multiple portions according to a first granularity. For example, memory system 110 can divide the memory array into different blocks 170. For each portion, memory system 110 can use counters to track the number of executed read commands, with each counter corresponding to a different portion. In some instances, the counters can be stored at memory system controller 115 or memory device 130. Memory system 110 can periodically (or non-periodically, such as in response to a trigger) compare the number of executed read commands for these portions to a baseline threshold. If the number of executed read commands associated with a portion meets the baseline threshold, memory system 110 can adjust the granularity of read tracking for that portion. For example, if the portion exceeds the baseline threshold, memory system 110 can subdivide the portion into multiple second portions according to a second granularity. As an example, if one or more portions are block 170, the memory system 110 can use counters to track read commands executed on page 175 of block 170, adjusting the track of read commands to the page level from block-level granularity. That is, the memory system 110 can store additional counters, each corresponding to a different second portion at a second granularity.

[0045] In some instances, memory system 110 can repeat this process and dynamically adjust the tracking granularity of different portions of the memory array (e.g., increase granularity, decrease granularity, or maintain granularity). Memory system 110 can periodically compare the number of executed read commands associated with a tracked portion (e.g., corresponding to any number of portions with different granularities) to a baseline threshold and adjust the granularity accordingly. As another example, memory system 110 can perform read interference remediation operations on the tracked portion. That is, memory system 110 can compare the number of executed command reads for a portion to a reliability threshold. If the number of executed command reads for one or more portions exceeds a reliability threshold (e.g., the same reliability threshold or a granularity-related reliability threshold), memory system 110 can rewrite the data stored in one or more portions to one or more other locations to support read interference remediation.

[0046] Figure 2 An example of a system 200 supporting techniques for adjusting the granularity associated with readout interference tracking, as disclosed herein, is shown. System 200 may be as described in reference... Figure 1An example of system 100 as described in reference . System 200 may include a memory system 210 configured to store data received from host system 205 and to send data to host system 205 if requested by host system 205 using an access command (e.g., a read command or a write command). System 200 may implement as described in reference . Figure 1 The described aspects of system 100. For example, memory system 210 and host system 205 may be instances of memory system 110 and host system 105, respectively.

[0047] Memory system 210 may include memory device 240 for storing, for example, data transferred between memory system 210 and host system 205 in response to receiving an access command from host system 205, as described herein. Memory device 240 may include, as referenced... Figure 1 The memory device 240 may include one or more memory devices. For example, memory device 240 may include NAND memory, PCM, self-select memory, 3D cross-point memory, other chalcogenide-based memory, FERAM, MRAM, NOR (e.g., NOR flash memory), STT-MRAM, CBRAM, RRAM, or OxRAM.

[0048] Memory system 210 may include a memory controller 230 for controlling the transfer of data directly to and from memory device 240, such as for storing data, retrieving data, and determining memory locations where data is to be stored and retrieved. The memory controller 230 may communicate with memory device 240 directly or via a bus (not shown) using protocols specific to each type of memory device 240. In some cases, a single memory controller 230 may be used to control multiple memory devices 240 of the same or different types. In some cases, memory system 210 may include multiple memory controllers 230, for example, different memory controllers 230 for each type of memory device 240. In some cases, the memory controller 230 may be implemented as described in the reference. Figure 1 Aspects of the local controller 135 described.

[0049] The memory system 210 may additionally include an interface 220 for communicating with the host system 205 and a buffer 225 for temporarily storing data transferred between the host system 205 and the memory device 240. The interface 220, buffer 225, and memory controller 230 may be used to transfer data between the host system 205 and the memory device 240, for example, as shown by data path 250, and may be collectively referred to as the data path components.

[0050] Temporarily storing data using buffer 225 during transmission allows data to be buffered while commands are being processed, thereby reducing latency between commands and allowing for arbitrary data sizes associated with commands. This also allows for processing command bursts, and once the burst stops, buffered data can be stored or transmitted (or both). Buffer 225 may contain relatively fast memory (e.g., some type of volatile memory such as SRAM or DRAM) or hardware accelerators or both to allow for fast storage and retrieval of data in and out of buffer 225. Buffer 225 may include data path switching components for bidirectional data transfer between buffer 225 and other components.

[0051] The temporary storage of data in buffer 225 can refer to the storage of data in buffer 225 during the execution of an access command. That is, after the access command is completed, the associated data may no longer be maintained in buffer 225 (e.g., it can be overwritten with data from an additional access command). Furthermore, buffer 225 can be a non-cached buffer. That is, data cannot be read directly from buffer 225 by the host system 205. For example, a read command can be added to a queue without requiring an operation to match the address with an address already in buffer 225 (e.g., no cached address matching or lookup operation is needed).

[0052] The memory system 210 may additionally include a memory system controller 215 for executing commands received from the host system 205 and controlling data path components when moving data. The memory system controller 215 may be as described in reference... Figure 1 An example of a memory system controller 115 is described. Bus 235 can be used for communication between system components.

[0053] In some cases, one or more queues (e.g., command queue 260, buffer queue 265, and storage queue 270) may be used to control the processing of access commands and the movement of corresponding data. For example, this may be advantageous if more than one access command from host system 205 is processed in parallel via memory system 210. Command queue 260, buffer queue 265, and storage queue 270 are depicted at interface 220, memory system controller 215, and storage controller 230, respectively, as examples of possible implementations. However, queues (if used) may be located anywhere within memory system 210.

[0054] Data transferred between host system 205 and memory device 240 may take a different path within memory system 210 than non-data information (e.g., commands, status information). For example, system components in memory system 210 may communicate with each other using bus 235, while data may use data path 250 via data path component instead of bus 235. Memory system controller 215 may control how and whether data is transferred between host system 205 and memory device 240 by communicating with data path component via bus 235 (e.g., using a protocol specific to memory system 210).

[0055] If host system 205 transmits an access command to memory system 210, the command can be received by interface 220, for example, according to a protocol (e.g., UFS protocol or eMMC protocol). Therefore, interface 220 can be considered the front end of memory system 210. Upon receiving each access command, interface 220 can transmit the command to memory system controller 215, for example, via bus 235. In some cases, each command can be added to command queue 260 via interface 220 to transmit the command to memory system controller 215.

[0056] The memory system controller 215 can determine whether an access command has been received based on communication from the interface 220. In some cases, the memory system controller 215 can determine that an access command has been received by retrieving the command from the command queue 260. After, for example, the command is retrieved from the command queue 260 by the memory system controller 215, the command can be removed from the command queue. In some cases, the memory system controller 215 can, for example, cause the interface 220 to remove the command from the command queue 260 via the bus 235.

[0057] Once it is determined that an access command has been received, the memory system controller 215 can execute the access command. For a read command, this may mean obtaining data from the memory device 240 and transferring the data to the host system 205. For a write command, this may mean receiving data from the host system 205 and moving the data to the memory device 240.

[0058] In either case, the memory system controller 215 may use the buffer 225 to temporarily store data received from or sent to the host system 205, and for other purposes. The buffer 225 may be considered as an intermediate part of the memory system 210. In some cases, buffer address management (e.g., pointers to locations in the buffer 225) may be performed by hardware (e.g., dedicated circuitry) in the interface 220, the buffer 225, or the memory controller 230.

[0059] In order to process a write command received from host system 205, memory system controller 215 may first determine whether buffer 225 has sufficient available space to store the data associated with the command. For example, memory system controller 215 may determine the amount of space within buffer 225 available for storing the data associated with the write command, for example via firmware (e.g., controller firmware).

[0060] In some cases, buffer queue 265 can be used to control the flow of commands associated with data stored in buffer 225, including write commands. Buffer queue 265 can contain access commands associated with data currently stored in buffer 225. In some cases, commands in command queue 260 can be moved to buffer queue 265 by memory system controller 215 and can be retained in buffer queue 265 while the associated data is stored in buffer 225. In some cases, each command in buffer queue 265 can be associated with an address in buffer 225. That is, pointers indicating where the data associated with each command is stored in buffer 225 can be maintained. Using buffer queue 265, multiple access commands can be received sequentially from host system 205, and at least some portions of the access commands can be processed in parallel.

[0061] If buffer 225 has sufficient space to store the write data, memory system controller 215 can cause interface 220 to transmit an availability indication (e.g., a "ready to transfer" indication) to host system 205, for example, according to a protocol (e.g., UFS protocol or eMMC protocol). When interface 220 subsequently receives data associated with the write command from host system 205, interface 220 can use data path 250 to transfer the data to buffer 225 for temporary storage. In some cases, interface 220 can obtain the location where data is stored within buffer 225 from buffer 225 or buffer queue 265. Interface 220 can indicate to memory system controller 215, for example, via bus 235 whether the data transfer to buffer 225 has been completed.

[0062] Once written data has been stored in buffer 225 via interface 220, the data can be transferred outside buffer 225 and stored in memory device 240. This can be accomplished using memory controller 230. For example, memory system controller 215 can cause memory controller 230 to retrieve data outside buffer 225 using data path 250 and transfer the data to memory device 240. Memory controller 230 can be considered as the back-end of memory system 210. Memory controller 230 can, for example, indicate to memory system controller 215 via bus 235 that data transfer to memory device 240 has been completed.

[0063] In some cases, storage queue 270 can be used to assist in the transfer of write data. For example, memory system controller 215 can push write commands from buffer queue 265 (e.g., via bus 235) to storage queue 270 for processing. Storage queue 270 may contain entries for each access command. In some instances, storage queue 270 may additionally contain: a buffer pointer (e.g., an address) indicating where in buffer 225 the data associated with the command is stored; and a storage pointer (e.g., an address) indicating the location in memory device 240 associated with the data. In some cases, storage controller 230 can obtain the location within buffer 225 from buffer 225, buffer queue 265, or storage queue 270, and obtain data from said location. Storage controller 230 can manage the location of stored data in memory device 240 (e.g., for wear leveling, garbage collection, and the like). These entries can be added to storage queue 270, for example, via memory system controller 215. When the data transfer is complete, an entry is removed from the storage queue 270, for example, by the storage controller 230 or the memory system controller 215.

[0064] In order to process a read command received from host system 205, memory system controller 215 may again first determine whether buffer 225 has sufficient available space to store the data associated with the command. For example, memory system controller 215 may determine the amount of space available in buffer 225 to store the data associated with the read command, for example via firmware (e.g., controller firmware).

[0065] In some cases, buffer queue 265 can be used to supplement buffer storage of data associated with read commands in a manner similar to that discussed above regarding write commands. For example, if buffer 225 has sufficient space to store read data, memory system controller 215 can cause memory controller 230 to retrieve the data associated with the read command from memory device 240 and store the data in buffer 225 for temporary storage using data path 250. Memory controller 230 can indicate to memory system controller 215, for example via bus 235, that the data transfer to buffer 225 has been completed.

[0066] In some cases, the storage queue 270 can be used to assist in the transfer of read data. For example, the memory system controller 215 can push a read command to the storage queue 270 for processing. In some cases, the storage controller 230 can obtain the location of data retrieved from the memory device 240 from the buffer 225 or the storage queue 270. In some cases, the storage controller 230 can obtain the location of data stored in the buffer 225 from the buffer queue 265. In some cases, the storage controller 230 can obtain the location of stored data in the buffer 225 from the storage queue 270. In some cases, the memory system controller 215 can move commands processed by the storage queue 270 back to the command queue 260.

[0067] Once data has been stored in buffer 225 by storage controller 230, it can be retrieved from buffer 225 and sent to host system 205. For example, storage system controller 215 can cause interface 220 to retrieve data from buffer 225 using data path 250 and transfer the data to host system 205, for example, according to a protocol (e.g., UFS or eMMC). For instance, interface 220 can process commands from command queue 260 and can indicate to storage system controller 215, for example, via bus 235, that the data transfer to host system 205 has been completed.

[0068] The memory system controller 215 can execute received commands in a sequence (e.g., according to the first-in-first-out order of the command queue 260). For each command, the memory system controller 215 can cause the data corresponding to the command to move in and out of buffer 225, as discussed above. As the data is moved and stored in buffer 225, the command can remain in buffer queue 265. If the processing of the command has been completed (e.g., if the data corresponding to the access command has been transferred out of buffer 225), the command can be removed from buffer queue 265, for example, by the memory system controller 215. If a command is removed from buffer queue 265, the address where the data previously associated with the command was stored can be used to store the data associated with the new command.

[0069] The memory system controller 215 may be additionally configured for operations associated with the memory device 240. For example, the memory system controller 215 may perform or manage operations such as wear leveling, garbage collection, error control operations such as error detection or error correction, encryption, caching, media management, background refresh, health monitoring, and address translation between logical addresses (e.g., LBAs) associated with commands from the host system 205 and physical addresses (e.g., physical block addresses) associated with memory cells within the memory device 240. That is, the host system 205 may issue commands indicating one or more LBAs, and the memory system controller 215 may recognize one or more physical block addresses indicated by the LBAs. In some cases, one or more consecutive LBAs may correspond to non-consecutive physical block addresses. In some cases, the memory controller 230 may be configured to perform one or more of the above operations in conjunction with or in place of the memory system controller 215. In some cases, the memory system controller 215 may perform the functions of the memory controller 230, and the memory controller 230 may be omitted.

[0070] In some instances, memory system 210 may receive read commands from host system 205. A read command may instruct memory system 210 to read data stored at a location in the memory array of memory device 240. In some instances, memory system 210 may track the number of read commands executed at different portions of the memory array. For example, memory system 210 may divide the memory array into different portions according to a first granularity. Dividing the memory array according to the first granularity may involve tracking read commands executed at different pages of the memory array. Each portion may correspond to a different counter 275 for tracking executed read commands, and memory system 210 may store counter 275 at memory system 210. For example, memory system 210 may store counter 275 at memory system controller 215 (e.g., in SRAM) or at memory device 240. If a read command associated with a portion is executed, memory system 210 may locate the counter 275 associated with said portion and increment counter 275.

[0071] In some instances, the memory system 210 may periodically (e.g., daily) compare the counter 275 to one or more thresholds. In some instances, the one or more thresholds may include one or both of a first threshold and a second threshold. The first threshold may be associated with a reliability threshold, where the reliability threshold may correspond to a threshold number of times data can be accessed before it may experience read interference effects. For example, the first threshold may be a reliability threshold divided by a specific period. In some instances, the memory system 210 may have a pre-configured reliability threshold. That is, the reliability threshold may be device-specific (e.g., memory device-specific). The second threshold may be less than the first threshold. As an example, the reliability threshold may be 100,000 executed read commands, and the memory array may be refreshed every 30 days. If the memory system 210 periodically checks the counter 275 daily, the first threshold may be 3,333 executed read commands per day, and the second threshold may be less than 3,333 executed read commands per day. In some cases, the first threshold may trigger an increase in the granularity of read interference tracking, and the second threshold may trigger a decrease in the granularity of read interference tracking. In some instances, once the memory system 210 compares the counter 275 with a first threshold, a second threshold, or both, the memory system 210 can subtract the first threshold from the counter 275 (or set the counter 275 to zero if subtracting the first threshold results in a negative value).

[0072] If the number of executed read commands associated with one or more portions exceeds a first threshold, memory system 210 may increase the tracking granularity of the one or more portions to a second granularity. For example, memory system 210 may divide the one or more portions into multiple second portions according to the second granularity. As an example, if the one or more portions are blocks, the second portions may be a set of word lines. Memory system 210 may track the number of executed read commands for each second portion instead of one or more portions. That is, memory system 210 may store additional counters 275, where each additional counter corresponds to a second portion. In some instances, memory system 210 may remove (or deactivate) the counters 275 corresponding to one or more portions and reallocate memory to store the counters 275 corresponding to the second portions. In some other instances, memory system 210 may reuse the counters 275 corresponding to one or more portions as counters for the second portions and may add one or more additional counters 275 to support the increased granularity of the second portions. In some instances, memory system 210 may perform read interference remedies for the second portions, as described in the reference... Figure 1Alternatively, if the number of executed read commands associated with one or more portions of the memory array does not exceed a first threshold, the memory system 210 may not increase the tracking granularity of one or more portions.

[0073] In some cases, if the number of executed read commands associated with one or more portions does not exceed a second threshold, the memory system 210 may reduce the tracking granularity of one or more portions. For example, the memory system 210 may group one or more portions into one or more third portions, where the number of third portions is less than the initial number of portions. As an example, if the memory portion is a page, the one or more third portions may be blocks. The memory system 210 may track the number of executed read commands for one or more third portions instead of one or more portions. That is, the memory system 210 may store additional counters 275 associated with one or more third portions. In some instances, the memory system 210 may remove (or deactivate) the counters corresponding to one or more portions and reallocate memory to store the counters 275 corresponding to one or more third portions.

[0074] In some cases, the first threshold and the second threshold can be the same, such that if the threshold is exceeded, the memory system can increase the granularity, and if the threshold is not met, the memory system can decrease the granularity. Alternatively, the first threshold and the second threshold can be different, wherein the first threshold and the second threshold can define an upper and lower limit of a range, respectively, and the granularity can remain unchanged.

[0075] In some instances, memory system 210 may use a data organization structure (e.g., a binary tree) to locate and increment counter 275. The root node of the binary tree may correspond to the coarsest granularity. As the granularity changes, nodes can be removed from the binary tree, added to the binary tree, or both. If a read command is executed at a location in the memory array, memory system 210 may search the binary tree for the counter 275 corresponding to the location in the memory array and increment counter 275 to track the executed read command. The techniques described herein can allow memory system 210 to locate regions in the memory array that are accessed more frequently than other regions of the memory array. Memory system 210 may adjust the tracking granularity (e.g., using counter 275) and perform read interference remediation operations accordingly.

[0076] Figure 3 An example of a counter storage scheme 300 supporting techniques for adjusting the granularity associated with readout interference tracking, as disclosed herein, is shown. In some instances, the counter storage scheme 300 may implement aspects of system 100 and system 200. For example, the counter storage scheme 300 may include a counter 305, which may be as described in reference... Figure 2 An example of counter 275 is described. Additionally, memory systems (e.g., as referenced) Figure 1 and 2 The memory system 110 or memory system 210 described can execute the counter storage scheme 300.

[0077] For reference Figure 2 The memory system can be configured with one or more thresholds associated with read tracking. For example, the memory system can be configured with a first threshold for increasing the granularity of read tracking, a second threshold for decreasing the granularity of read tracking, or both. The first threshold can be determined using conditions such as the memory system's refresh cycle, a threshold (e.g., a maximum) number of read commands before data retirement (e.g., to mitigate read interference), the period at which the number of executed read commands is checked, or any combination thereof. For example, the first threshold could be the threshold number of read commands before data retirement divided by the refresh cycle divided by the period at which the number of executed read commands is checked. In one instance, if the threshold number of executed read commands for data retirement is 100,000, the refresh cycle is 30 days, and the period at which the number of executed read commands is checked is once a day, then the first threshold could be 3,333 executed read commands per day. In some instances, the second threshold can be lower than the first threshold. For example, the second threshold can be determined using the first threshold and a procedure for decreasing granularity. For example, if the procedure for reducing granularity involves combining four parts of a first granularity into a single part of a second granularity, then the second threshold could be one-quarter of the first threshold.

[0078] At time T0, the memory system can track executed read commands of the memory array according to a first granularity. For example, the memory system can divide the memory array into portions 310, and a counter 305-a corresponding to portion 310 can be stored at the memory system (e.g., at the memory system controller). When a read command is executed at portion 310, the memory system can increment the counter 305-a. In some instances, the memory system can periodically (e.g., daily) check the counter 305-a to determine whether the counter 305-a meets one of a first threshold or a second threshold.

[0079] In some instances, the memory system can determine whether counter 305-a exceeds (e.g., exceeds) a first threshold at time T1, and can increase the granularity associated with read tracking of portion 310. For example, the memory system can divide portion 310 according to a second granularity. That is, the memory system can divide portion 310 into portion 315-a and portion 315-b. The memory system can additionally store counters 305 (e.g., counters 305-b and 305-c, respectively) corresponding to portions 315-a and 315-b to track read commands for portions 315-a and 315-b. In some instances, the memory system can deactivate counter 305-a in response to an increase in granularity, and reallocate the memory used to store counter 305-a for other operations. In some instances, the memory system can repeat the process described above. In other words, the memory system can periodically check counters 305-b and 305-c and determine whether counters 305-b, 305-c, or both meet one of a first threshold or a second threshold. Alternatively, the memory system can stop granularity adjustment (e.g., after completing the initial adjustment process for setting the tracking granularity) and can use counters 305-b and 305-c to perform read interference remediation operations on portions 315-a, 315-b, or both.

[0080] In some instances, the memory system can determine whether counter 305-b exceeds a first threshold at time T2 and can increase the granularity associated with the read tracking of portion 315-a. For example, the memory system can divide portion 315-a according to a third granularity. That is, the memory system can divide portion 315-a into portion 320-a and portion 320-b, and can store counters 305 corresponding to portions 320-a and 320-b (e.g., counters 305-d and 305-e, respectively). In some instances, the memory system can deactivate counter 305-b in response to the increase in granularity, and can reallocate the memory used to store counter 305-b for other operations. Furthermore, the memory system can determine whether counter 305-c does not exceed (e.g., does not exceed) the first threshold at time T2 and can maintain the tracking granularity for portion 315-b. That is, the memory system can either add or deactivate any counters associated with portion 315-b at time T2. Therefore, memory systems can use different granularities to track read commands executed for different portions of the memory array. By dynamically adjusting the granularity, memory systems can perform efficient tracking of read commands to support read interference mitigation. For example, a memory system can perform relatively high-granularity tracking (e.g., high-resolution tracking, such as at the page level, page line group level, or word line level) in portions of the memory array where relatively frequent read operations are performed to support targeted and efficient read interference mitigation, and can perform relatively low-granularity tracking (e.g., virtual block level or block level) in portions of the memory array where relatively infrequent read operations are performed to support memory and processing resource savings.

[0081] In some instances, the memory system can repeat the process described above. That is, the memory system can periodically check counters 305-d, 305-e, and 305-c and determine whether any counter 305 meets one of a first threshold or a second threshold. Alternatively, the memory system can stop granular adjustment and use counters 305 to perform read interference remediation operations on portions 320-a, 320-b, 315-b, or some combination thereof.

[0082] The memory system can store counter 305 hierarchically. For example, the memory system can store counter 305 according to a tree structure or another data structure. If a binary tree structure is used to store counter 305, the counter associated with the coarsest granularity can correspond to the root node of the tree. For example, counter 305-a can correspond to node 325-a. If counter 305-a exceeds a first threshold at time T1, the memory system can mark node 325-a and add nodes 325-b and 325-c to the tree structure, where nodes 325-b and 325-c can be child nodes of node 325-a. Node 325-b can correspond to counter 305-b, and node 325-c can correspond to counter 305-c. If a read command is executed on one or more memory cells located within portion 315-a of the memory array at time T1 (or later), the memory system can traverse the tree to identify node 325-b corresponding to this or more memory cells and increment the corresponding counter 305-b. In other words, when creating nodes 325-b and 325-c, the memory system can determine the logic used for traversing from node 325-a. For example, if the executed read command indicates an address within the memory array (e.g., an LBA, physical address) in the first set of addresses, the memory system can traverse from node 325-a to node 325-b, and if the address within the memory array is in the second set of addresses, the memory system can traverse from node 325-a to node 325-c. Once the memory system reaches node 325 and there are no other branches in the binary tree, the memory system can determine to increment the counter 305 corresponding to node 325.

[0083] For example, if counter 305-b exceeds a first threshold at time T2, the memory system can mark node 325-b and add nodes 325-d and 325-e to the tree structure, where nodes 325-d and 325-e are child nodes of node 325-b. Node 325-d can correspond to counter 305-d, and node 325-e can correspond to counter 305-e. If a read command is executed at part 320-a at time T2 (or later), the memory system can traverse the tree to node 325-d and increment the corresponding counter 305-d. That is, the memory system can recognize that node 325-b has child node 325 and can continue down the tree to node 325-d. In some instances, node 325 can also be removed from the tree. For example, if the memory system determines that portions 320-a and 320-b do not exceed a first threshold and are below a second threshold at a later time, the memory system can reduce the granularity used for read tracking and combine portions 320-a and 320-b into a common portion for tracking (e.g., portion 315-a). In this instance, one or more nodes 325 (e.g., nodes 325-d and 325-e) can be removed from the binary tree to reflect the reduction in granularity and allow the memory system to accurately determine which counter 305 to increment for an executed read command.

[0084] Figure 4 An example of a process flow 400, based on examples disclosed herein, supporting techniques for adjusting the granularity associated with read interference tracking, is shown. Process flow 400 can be performed by a memory system (or one or more components thereof), for example, as referenced... Figure 1 and 2 The memory system 110 or memory system 210 is described. In some cases, alternative instances may be implemented, some of which may be performed in a different order than described or not at all. Additionally or alternatively, operations may include additional features not mentioned below, or other processes may be added.

[0085] At position 405, a set of read commands is received from the host system. These read commands can be instances of access commands and can instruct the memory system to read data stored in the memory device.

[0086] At 410, the number of executed read commands corresponding to a first portion of the memory array is tracked according to a first granularity. The first granularity can be an instance of memory array-level granularity, virtual block-level granularity, block-level granularity, page-level granularity, page line group-level granularity, word line-level granularity, or any other supported granularity. If a read command is executed at the first portion of the memory array, the memory system can increment a counter associated with the first portion. To locate the counter associated with the first portion, the memory system can search for data (e.g., data stored according to a tree structure). In some instances, one or both of the counter or the data can be stored in the memory system controller of the memory system.

[0087] At 415, it can be determined (e.g., by the memory system) whether the number of read commands corresponding to the first portion of the memory array meets a threshold during the first duration. Meeting the threshold may involve the number of read commands corresponding to the first portion being lower or higher than the threshold. In some instances, the memory system may maintain a real-time clock (RTC) and may determine whether the number of read commands corresponding to the first portion meets the threshold after the first duration (e.g., 24 hours) has elapsed using the RTC. If the number of read commands corresponding to the first portion meets the threshold, then at 420, the memory system may adjust the granularity of tracking read commands. If the number of read commands corresponding to the first portion does not meet the threshold, the memory system may continue to track executed read commands for the first portion using a first granularity (e.g., at 410).

[0088] At 420, the first granularity is switched to a second granularity to track the number of executed read commands. If the number of executed read commands corresponding to the first portion exceeds a threshold, the memory system can increase the granularity used for tracking. That is, the memory system can track a second set of executed read commands corresponding to a corresponding sub-part of the first portion of the memory array according to the second granularity. In another instance, if the number of executed read commands corresponding to the first portion is below a threshold, the memory system can decrease the granularity used for tracking. As the granularity used for tracking changes, the data used for the storage counter may change. For example, if the granularity used for tracking increases, one or more additional nodes can be added to the data, and if the granularity decreases, one or more nodes can be removed. As an example, if the granularity increases, one or more additional nodes corresponding to a sub-part of the first portion of the memory array can be added. In some instances, the second granularity may be an instance of memory array-level granularity, virtual block-level granularity, block-level granularity, page-level granularity, page line group-level granularity, word line-level granularity, or any other supported granularity (e.g., different from the first granularity).

[0089] Process flow 400 can enable the memory system to maintain relatively high-resolution read counts for areas of the memory array that are accessed relatively frequently and are correspondingly at risk of read interference reliability issues. However, the memory system can maintain relatively low-resolution read counts for other areas of the memory array that are accessed relatively infrequently to improve memory utilization, while still tracking information associated with read interference mitigation (e.g., what data is accessed most frequently, how often the data is accessed, where the data is stored, whether the data should be accessed for migration or remediation, or some combination of information).

[0090] Various aspects of process flow 400 can be implemented by controllers and other components in a system (such as a memory system). For example, a memory system controller of the memory system can execute one or more aspects of process flow 400. Alternatively, aspects of process flow 400 can be implemented as instructions stored in memory (e.g., firmware stored in memory coupled to the memory system). For example, if the instructions are executed by a controller (e.g., a memory system controller), the controller can perform operations of process flow 400.

[0091] Figure 5 A block diagram 500 of a memory system 520 supporting techniques for adjusting the granularity associated with read interference tracking, according to an example disclosed herein, is shown. The memory system 520 may be as described in the reference... Figures 1 to 4 Examples of aspects of the described memory system. Memory system 520 or its various components may be examples of means for performing various aspects of adjusting the granularity associated with read interference tracking as described herein. For example, memory system 520 may include read command component 525, command tracking component 530, threshold component 535, granularity component 540, interference remedy component 545, clock component 550, data storage component 555, or any combination thereof. Each of these components may communicate with each other directly or indirectly (e.g., via one or more buses). In some instances, memory system 520 may be an example of a device comprising a memory device and a controller coupled to the memory device and configured to cause the device to perform one or more operations described herein. In some cases, the memory device may comprise a memory array, and the memory array may comprise one or more memory cells for storing data.

[0092] The read command component 525 may be configured or otherwise supported to support means for receiving a plurality of read commands for accessing one or more memory cells of a memory array (e.g., a memory device). The command tracking component 530 may be configured or otherwise supported to support means for tracking the number of executed read commands corresponding to a first portion of the memory array according to a first granularity, the tracking being at least partially based on (e.g., in response to) the number of executed read commands. The threshold component 535 may be configured or otherwise supported to support means for determining whether the number of executed read commands corresponding to the first portion of the memory array meets a threshold during a first duration. The granularity component 540 may be configured or otherwise supported to support means for switching from a first granularity to a second granularity to track the number of executed read commands corresponding to the first portion of the memory array, at least partially based on (e.g., in response to) determining that the number of executed read commands corresponding to the first portion of the memory array meets a threshold during a first duration.

[0093] In some instances, the number of executed read commands corresponding to a first portion of the memory array meets a threshold during a first duration, at least in part based on (e.g., because) the number of executed read commands exceeds a first threshold. In some such instances, to support a switch from a first granularity to a second granularity, the granularity component 540 may be configured or otherwise support means for increasing the granularity used to track the number of executed read commands corresponding to the first portion of the memory array.

[0094] In some instances, the number of executed read commands corresponding to the first portion of the memory array meets the threshold during a first duration, at least in part based on (e.g., because) the number of executed read commands is less than a second threshold. In some such instances, to support a switch from a first granularity to a second granularity, the granularity component 540 may be configured or otherwise support means for reducing the granularity used to track the number of executed read commands corresponding to the first portion of the memory array.

[0095] In some instances, to support tracking the number of executed read commands corresponding to a first portion of the memory array according to a first granularity, the command tracking component 530 may be configured or otherwise support means for searching data of a counter corresponding to the first portion of the memory array based at least in part on (e.g., in response to) executing a read command among a plurality of read commands for accessing memory cells corresponding to the first portion of the memory array. In some instances, to support tracking the number of executed read commands corresponding to the first portion of the memory array according to a first granularity, the command tracking component 530 may be configured or otherwise support means for incrementing a counter at least in part on (e.g., in response to) executing a read command.

[0096] In some instances, the command tracing component 530 may be configured or otherwise support means for updating data at least in part based on (e.g., in response to) switching from a first granularity to a second granularity, for tracking the number of executed read commands corresponding to a first portion of the memory array.

[0097] In some instances, to support data updates, command tracing component 530 may be configured or otherwise supported to support means for adding one or more additional nodes to the data, at least in part, based on (e.g., in response to) a switch from a first granularity to a second granularity and a second granularity greater than the first granularity. In some instances, to support data updates, command tracing component 530 may be configured or otherwise supported to support means for removing one or more nodes from the data, at least in part, based on (e.g., in response to) a switch from a first granularity to a second granularity and a first granularity greater than the second granularity.

[0098] In some instances, the data storage component 555 may be configured or otherwise support means for storing data, counters, or both in the memory system controller of the memory system.

[0099] In some instances, the command tracing component 530 may be configured or otherwise support means for tracking a plurality of second number of executed read commands corresponding to a respective sub-part of a first portion of a memory array, based at least in part on (e.g., due to) a switch from a first granularity to a second granularity and the fact that the second granularity is greater than the first granularity.

[0100] In some instances, the command tracing component 530 may be configured or otherwise support means for activating a plurality of second counters at least in part based on (e.g., in response to) a switch from a first granularity to a second granularity and the second granularity being greater than the first granularity, the plurality of second counters indicating a corresponding second number of a plurality of second numbers of executed read commands.

[0101] In some instances, threshold component 535 may be configured or otherwise support means for determining whether a second number of a plurality of second numbers of executed read commands corresponding to a respective sub-part of a first portion of the memory array satisfies a second threshold during a second duration. In some instances, granularity component 540 may be configured or otherwise support means for switching from a second granularity to a third granularity, at least in part based on (e.g., in response to) determining that a second number of a plurality of second numbers of executed read commands corresponding to a respective sub-part of the first portion of the memory array satisfies a second threshold during a second duration, in order to track the second number of a plurality of second numbers of executed read commands corresponding to a respective sub-part of the first portion of the memory array.

[0102] In some instances, threshold component 535 may be configured or otherwise support means for determining whether a second number of a plurality of second numbers of executed read commands corresponding to a respective sub-part of a first portion of the memory array satisfies a second threshold during a second duration. In some instances, granularity component 540 may be configured or otherwise support means for avoiding switching from a second granularity at least in part based on (e.g., in response to) determining that a second number of a plurality of second numbers of executed read commands corresponding to a respective sub-part of the first portion of the memory array fails to satisfy a second threshold during a second duration, in order to track the second number of a plurality of second numbers of executed read commands corresponding to a respective sub-part of the first portion of the memory array.

[0103] In some instances, the command tracking component 530 may be configured or otherwise support a means for resetting a second counter indicating the second number of executed read commands based at least in part on determining that a second number of a plurality of second number of executed read commands corresponding to a respective sub-part of a first portion of the memory array has failed to meet a second threshold during a second duration (e.g., after determination).

[0104] In some instances, the command tracing component 530 may be configured or otherwise support a device for revoking a counter indicating the number of read commands executed, at least in part based on (e.g., in response to) a switch from a first granularity to a second granularity and the fact that the first granularity is greater than the second granularity.

[0105] In some instances, the interference remedy component 545 may be configured or otherwise support means for performing read interference remedies on the first portion of the memory array at least in part based on (e.g., in response to) determining that the number of executed read commands corresponding to the first portion of the memory array meets a threshold during a first duration.

[0106] In some instances, clock component 550 may be configured or otherwise support means for maintaining RTC. In some instances, clock component 550 may be configured or otherwise support means for using RTC to identify that a first duration has elapsed, wherein determining whether the number of executed read commands corresponding to a first portion of the memory array meets a threshold during the first duration is triggered at least in part based on (e.g., in response to) identifying that the first duration has elapsed.

[0107] In some instances, the first granularity includes memory array-level granularity, virtual block-level granularity, block-level granularity, page-level granularity, page line group-level granularity, or word line-level granularity, and the second granularity differs from the first granularity and includes memory array-level granularity, virtual block-level granularity, block-level granularity, page-level granularity, page line group-level granularity, or word line-level granularity.

[0108] In some instances, the threshold, the first duration, or both are at least partially based on the refresh cycle of the memory array, the read threshold used to de-encode data in the memory array, or both (e.g., used to determine this).

[0109] Figure 6 A flowchart illustrating method 600 according to an example disclosed herein is shown, which supports techniques for adjusting the granularity associated with read interference tracking. Operation of method 600 can be implemented by a memory system or its components as described herein. For example, operation of method 600 can be implemented by, as referenced... Figures 1 to 5 The described memory system is used for execution. In some instances, the memory system can execute a set of instructions to control the functional elements of the device to perform the described function. Alternatively or concurrently, the memory system may use dedicated hardware to perform aspects of the described function.

[0110] At 605, the method may include receiving a plurality of read commands for accessing one or more memory cells of a memory array. The operation of 605 may be performed according to examples as disclosed herein. In some instances, aspects of the operation of 605 may be as described in references... Figure 5 The described read command component 525 is used to execute.

[0111] At 610, the method may include tracking the number of executed read commands corresponding to a first portion of the memory array according to a first granularity, the tracking being at least in part based on (e.g., in response to) the number of executed read commands. The operation of 610 may be performed according to examples as disclosed herein. In some instances, aspects of the operation of 610 may be as described in references... Figure 5 The command tracing component 530 is described for execution.

[0112] At 615, the method may include determining whether the number of executed read commands corresponding to the first portion of the memory array meets a threshold during a first duration. The operation of 615 can be performed according to examples as disclosed herein. In some instances, aspects of the operation of 615 may be as described in references... Figure 5 The threshold component 535 is described and executed.

[0113] At 620, the method may include switching from a first granularity to a second granularity, at least in part based on (e.g., in response to) determining that the number of executed read commands corresponding to a first portion of the memory array meets a threshold during a first duration, for tracking the number of executed read commands corresponding to the first portion of the memory array. The operation of 620 may be performed according to examples as disclosed herein. In some instances, aspects of the operation of 620 may be as described in references... Figure 5 The granular component 540 is described for execution.

[0114] In some instances, the device described herein may perform one or more methods, such as method 600. The device may include features, circuitry, logic, means, controllers (e.g., controllers coupled to memory devices) or instructions (e.g., a non-transitory computer-readable medium storing code containing instructions that, if executed by a processor of an electronic device, could cause the electronic device to perform operations), for receiving multiple read commands for accessing one or more memory cells of a memory array, tracking the number of executed read commands corresponding to a first portion of the memory array according to a first granularity, the tracking being at least partially based on (e.g., in response to) the number of executed read commands, determining whether the number of executed read commands corresponding to the first portion of the memory array satisfies a threshold during a first duration, and switching from a first granularity to a second granularity for tracking the number of executed read commands corresponding to the first portion of the memory array, at least partially based on (e.g., in response to) the determination that the number of executed read commands corresponding to the first portion of the memory array satisfies the threshold during the first duration.

[0115] In some instances of the method 600 and device described herein, at least in part based on (e.g., because) the number of executed read commands exceeds a first threshold, the number of executed read commands corresponding to a first portion of the memory array meets the threshold during a first duration, and switching from a first granularity to a second granularity may include operations, features, circuitry, logic, means, or instructions for increasing the granularity for tracking the number of executed read commands corresponding to the first portion of the memory array.

[0116] In some instances of the method 600 and device described herein, the number of executed read commands corresponding to a first portion of the memory array satisfies the threshold during a first duration, at least in part based on (e.g., because) the number of executed read commands is less than a second threshold, and the switch from the first granularity to the second granularity may include operations, features, circuitry, logic, means, or instructions for reducing the granularity used to track the number of executed read commands corresponding to the first portion of the memory array.

[0117] In some instances of the method 600 and apparatus described herein, tracking the number of executed read commands corresponding to a first portion of the memory array according to a first granularity may include operations, features, circuitry, logic, means, or instructions for searching data of a counter corresponding to the first portion of the memory array for accessing memory cells corresponding to the first portion of the memory array, at least in part based on (e.g., in response to) executing a read command among a plurality of read commands, and incrementing the counter at least in part based on (e.g., in response to) executing a read command.

[0118] Some instances of the methods 600 and devices described herein may further include operations, features, circuit systems, logic, means, or instructions for updating data at least in part based on (e.g., in response to) switching from a first granularity to a second granularity, for tracking the number of executed read commands corresponding to a first portion of the memory array.

[0119] In some instances of the method 600 and device described herein, updating data may include operations, features, circuitry, logic, means, or instructions for adding one or more additional nodes to the data, at least in part based on (e.g., in response to) a switch from a first granularity to a second granularity and a second granularity greater than the first granularity, or deleting one or more nodes from the data, at least in part based on (e.g., in response to) a switch from a first granularity to a second granularity and a first granularity greater than the second granularity.

[0120] Some examples of the methods 600 and devices described herein may further include operations, features, circuit systems, logic, means, or instructions for storing data, counters, or both in a memory system controller of a memory system.

[0121] Some examples of the methods 600 and devices described herein may further include operations, features, circuit systems, logic, means, or instructions for tracking a plurality of second number of executed read commands corresponding to respective sub-parts of a first portion of a memory array, based at least in part on (e.g., in response to) a switch from a first granularity to a second granularity and the second granularity being greater than the first granularity.

[0122] Some instances of the method 600 and device described herein may further include operations, features, circuitry, logic, means, or instructions for activating a plurality of second counters at least in part based on (e.g., in response to) a switch from a first granularity to a second granularity and a second granularity greater than the first granularity, the plurality of second counters indicating a corresponding second number of a plurality of second number of executed read commands.

[0123] Some examples of the method 600 and apparatus described herein may further include operations, features, circuit systems, logic, means, or instructions for determining whether a second number of a plurality of second numbers of executed read commands corresponding to a respective sub-part of a first portion of a memory array satisfies a second threshold during a second duration, and switching from a second granularity to a third granularity at least in part based on (e.g., in response to) determining that the second number of a plurality of second numbers of executed read commands corresponding to a respective sub-part of a first portion of a memory array satisfies the second threshold during a second duration, for tracking the second number of a plurality of second numbers of executed read commands corresponding to a respective sub-part of a first portion of a memory array.

[0124] Some examples of the method 600 and apparatus described herein may further include operations, features, circuitry, logic, means, or instructions for determining whether a second number of a plurality of second numbers of executed read commands corresponding to a respective sub-part of a first portion of the memory array satisfies a second threshold during a second duration, and at least in part based on (e.g., in response to) determining that the second number of a plurality of second numbers of executed read commands corresponding to a respective sub-part of the first portion of the memory array satisfies the second threshold during the second duration, avoiding switching from a second granularity for tracking the second number of a plurality of second numbers of executed read commands corresponding to a respective sub-part of the first portion of the memory array.

[0125] Some examples of the method 600 and apparatus described herein may further include operations, features, circuit systems, logic, means, or instructions for resetting a second counter indicating the second number of executed read commands, at least in part, based on determining that a second number of a plurality of second number of executed read commands corresponding to a respective sub-part of a first portion of a memory array has failed to meet a second threshold during a second duration (e.g., after determination).

[0126] Some instances of the methods 600 and devices described herein may further include operations, features, circuit systems, logic, means, or instructions for revoking a counter indicating the number of read commands executed, at least in part based on (e.g., in response to) a switch from a first granularity to a second granularity and the first granularity being greater than the second granularity.

[0127] Some examples of the methods 600 and devices described herein may further include operations, features, circuit systems, logic, means, or instructions for performing read interference remedies on the first portion of the memory array, at least in part based on (e.g., in response to) determining that the number of executed read commands corresponding to the first portion of the memory array meets a threshold during a first duration.

[0128] Some instances of the method 600 and device described herein may further include operations, features, circuitry, logic, means, or instructions for maintaining the RTC and using the RTC to identify that a first duration has elapsed, wherein determining whether the number of executed read commands corresponding to a first portion of the memory array meets a threshold during the first duration may be triggered at least in part based on (e.g., in response to) identifying that the first duration may have elapsed.

[0129] In some instances of the method 600 and device described herein, the first granularity includes memory array-level granularity, virtual block-level granularity, block-level granularity, page-level granularity, page line group-level granularity, or word line-level granularity, and the second granularity may differ from the first granularity and include memory array-level granularity, virtual block-level granularity, block-level granularity, page-level granularity, page line group-level granularity, or word line-level granularity.

[0130] In some instances of the method 600 and device described herein, the threshold, the first duration, or both may be based at least in part on the refresh cycle of the memory array, a read threshold for causing data to be de-escalated in the memory array, or both (e.g., used to determine this).

[0131] Aspects of method 600 may be implemented by a controller and other components. Alternatively or additionally, aspects of method 600 may be implemented as instructions stored in memory (e.g., firmware stored in memory coupled to a memory device comprising one or more memory cells of a memory array). For example, if the instructions are executed by a controller (e.g., a memory system controller), the controller may perform the operation of method 600.

[0132] It should be noted that the methods described above describe possible implementations, and the operations and steps may be rearranged or otherwise modified, and other implementations are possible. Furthermore, two or more parts from the methods described may be combined.

[0133] An apparatus is described. The apparatus may include a memory device and a controller, the controller being coupled to the memory device and configured such that the apparatus receives a set of read commands for accessing one or more memory cells of a memory array, tracks the number of executed read commands corresponding to a first portion of the memory array according to a first granularity, the tracking determining, based on the number of executed read commands, whether the number of executed read commands corresponding to the first portion of the memory array meets the threshold during a first duration, and, based on the determination that the number of executed read commands corresponding to the first portion of the memory array meets the threshold during the first duration, switches from the first granularity to a second granularity for tracking the number of executed read commands corresponding to the first portion of the memory array.

[0134] In some instances of the device, based on the number of executed read commands exceeding a first threshold, the number of executed read commands corresponding to a first portion of the memory array meets the threshold during a first duration, and the controller configured to cause the device to switch from a first granularity to a second granularity is configured to cause the device to increase the granularity for tracking the number of executed read commands corresponding to the first portion of the memory array.

[0135] In some instances of the device, based on the fact that the number of executed read commands is less than a second threshold, the number of executed read commands corresponding to the first portion of the memory array meets the threshold within a first duration, and the controller configured to cause the device to switch from a first granularity to a second granularity is configured to cause the device to reduce the granularity used to track the number of executed read commands corresponding to the first portion of the memory array.

[0136] In some instances of the device, the controller, configured to cause the device to track the number of executed read commands corresponding to a first portion of the memory array according to a first granularity, is configured to cause the device to search for data of a counter corresponding to the first portion of the memory array based on the read commands in the set of read commands executed to access memory cells corresponding to the first portion of the memory array, and to increment the counter based on the execution of the read commands.

[0137] In some instances of the device, the controller is further configured to cause the device to update data based on a switch from a first granularity to a second granularity for tracking the number of executed read commands corresponding to a first portion of the memory array.

[0138] In some instances of the device, the controller configured to cause the device to update data is configured to cause the device to add one or more additional nodes to the data based on a switch from a first granularity to a second granularity and the second granularity being greater than the first granularity, or to remove one or more nodes from the data based on a switch from a first granularity to a second granularity and the first granularity being greater than the second granularity.

[0139] In some instances of the device, the controller is further configured to cause the device to store data, counters, or both in the memory system controller of the memory system.

[0140] In some instances of the device, the controller is further configured such that the device, based on a switch from a first granularity to a second granularity and the second granularity being greater than the first granularity, tracks a second number of executed read commands corresponding to a respective sub-part of a first portion of the memory array at the second granularity.

[0141] In some instances of the device, the controller is further configured such that the device activates a set of second counters based on a switch from a first granularity to a second granularity and the second granularity being greater than the first granularity. The second counters indicate a corresponding second number of executed read commands in the set of second numbers.

[0142] In some instances of the device, the controller is further configured to cause the device to determine whether a second number of a second set of executed read commands corresponding to a corresponding sub-part of the first portion of the memory array satisfies a second threshold during a second duration, and based on the determination that the second number of a second set of executed read commands corresponding to a corresponding sub-part of the first portion of the memory array satisfies the second threshold during the second duration, switch from a second granularity to a third granularity for tracking the second number of a second set of executed read commands corresponding to a corresponding sub-part of the first portion of the memory array.

[0143] In some instances of the device, the controller is further configured to cause the device to determine whether a second number of a second set of executed read commands corresponding to a corresponding sub-part of the first portion of the memory array meets a second threshold during a second duration, and to avoid switching from a second granularity when it is determined that the second number of a second set of executed read commands corresponding to a corresponding sub-part of the first portion of the memory array fails to meet the second threshold during the second duration, for tracking the second number of a second set of executed read commands corresponding to a corresponding sub-part of the first portion of the memory array.

[0144] In some instances of the device, the controller is further configured such that the device resets a second counter indicating the second number of executed read commands based on the determination that a second number of a second set of second number of executed read commands corresponding to a corresponding sub-part of the first part of the memory array fails to meet a second threshold during a second duration.

[0145] In some instances of the device, the controller is further configured such that the device deactivates a counter indicating the number of read commands executed based on a switch from a first granularity to a second granularity and the first granularity being greater than the second granularity.

[0146] In some instances of the device, the controller is further configured to cause the device to perform read interference remedies on the first portion of the memory array based on determining that the number of executed read commands corresponding to the first portion of the memory array meets a threshold during a first duration.

[0147] In some instances of the device, the controller is further configured to cause the device to maintain an RTC and use the RTC to identify that a first duration has elapsed. In some instances of the device, a controller configured to cause the device to determine whether the number of executed read commands corresponding to a first portion of the memory array meets a threshold during the first duration can be configured to cause the device to trigger the determination of whether the number of executed read commands corresponding to the first portion of the memory array meets a threshold during the first duration based on the recognition that the first duration has elapsed.

[0148] In some instances of the device, the first granularity includes memory array-level granularity, virtual block-level granularity, block-level granularity, page-level granularity, page line group-level granularity, or word line-level granularity, and the second granularity differs from the first granularity and includes memory array-level granularity, virtual block-level granularity, block-level granularity, page-level granularity, page line group-level granularity, or word line-level granularity.

[0149] In some instances of the device, the threshold, the first duration, or both are based on the refresh cycle of the memory array, a read threshold for causing the data in the memory array to be deactivated, or both.

[0150] The information and signals described herein can be represented using any of a variety of different techniques and skills. For example, data, instructions, commands, information, signals, bits, symbols, and chips that may be mentioned throughout the foregoing description can be represented by voltage, current, electromagnetic waves, magnetic fields or particles, optical fields or particles, or any combination thereof. Some diagrams may show a signal as a single signal; however, a signal can represent a bus of signals, where the bus can have various bit widths.

[0151] The terms "electronic communication," "conductive contact," "connection," and "coupling" can refer to a relationship between components that supports the flow of signals between them. Components are considered to be in electronic communication with each other (or in conductive contact, connected, or coupled) if any conductive path exists between them that supports the flow of signals at any given time. At any given time, the conductive path between components that are in electronic communication (or in conductive contact, connected, or coupled) can be open or closed, depending on the operation of the device containing the connected components. The conductive path between connected components can be a direct conductive path between the components, or an indirect conductive path that may include intermediate components such as switches, transistors, or other components. In some instances, one or more intermediate components, such as switches or transistors, may be used to interrupt the signal flow between connected components for a period of time.

[0152] The term "coupling" refers to the condition that moves from an open-circuit relationship between components to a closed-circuit relationship. In an open-circuit relationship, signals cannot currently travel between components via a conductive path, while in a closed-circuit relationship, signals can travel between components via a conductive path. If a component, such as a controller, couples other components together, then the component initiates a change that allows signals to flow between other components via conductive paths that were previously not permitted.

[0153] The term "isolation" refers to a relationship between components where signals cannot currently flow between them. Components are isolated from each other if there is an open circuit between them. For example, components separated by a switch positioned between them are isolated from each other when the switch is open. If a controller isolates two components, it prevents signals from flowing between the components using previously permitted conductive paths.

[0154] As used in this article, the term “generally” means that the modified feature (e.g., a verb or adjective modified by the term “generally”) does not have to be absolute but must be close enough to obtain the advantage of the feature.

[0155] As used herein, the term "electrode" can refer to an electrical conductor and, in some instances, can be used as an electrical contact to a memory cell or other component of a memory array. Electrodes can include traces, wires, conductive lines, conductive materials, etc., that provide a conductive path between elements or components of the memory array.

[0156] The terms “if,” “when,” “based on,” or “at least partially based on” are used interchangeably. In some instances, the terms “if,” “when,” “based on,” or “at least partially based on” are used to describe a connection between conditional actions, conditional processes, or parts of a process.

[0157] The term "in response to" can refer to a condition or action that occurs at least partially (if not completely) as a result of a preceding condition or action. For example, a first condition or action may be performed, and a second condition or action may occur at least partially as a result of the preceding condition or action (whether directly after the first condition or action or after one or more other intermediate conditions or actions following the first condition or action).

[0158] Additionally, the terms "directly in response to" or "directly responding to" can refer to a condition or action occurring as a direct result of a previous condition or action. In some instances, a first condition or action may be performed, and a second condition or action may occur directly as a result of a previous condition or action, regardless of whether other conditions or actions occur. In some instances, a first condition or action may be performed, and a second condition or action may occur directly as a result of a previous condition or action, such that no other intermediate conditions or actions occur between the earlier condition or action and the second condition or action, or a limited number of one or more intermediate steps or actions occur between the earlier condition or action and the second condition or action. Unless otherwise specified, any condition or action described herein as "based on," "at least in part based on," or "in response to" a certain other step, action, event, or condition may additionally or alternatively (e.g., in alternative instances) "directly in response to" or "directly responding to" such other condition or action.

[0159] The devices discussed herein, including memory arrays, can be formed on semiconductor substrates such as silicon, germanium, silicon-germanium alloys, gallium arsenide, and gallium nitride. In some instances, the substrate is a semiconductor wafer. In other instances, the substrate can be a silicon-on-insulator (SOI) substrate, such as silicon-on-glass (SOG) or silicon-on-sapphire (SOP), or an epitaxial layer of semiconductor material on another substrate. The conductivity of the substrate or subregions of the substrate can be controlled by doping with various chemicals including, but not limited to, phosphorus, boron, or arsenic. Doping can be performed during the initial formation or growth of the substrate, either by ion implantation or by any other doping method.

[0160] The switching components or transistors discussed herein may represent field-effect transistors (FETs) and include a three-terminal device comprising a source, drain, and gate. The terminals may be connected to other electronic components via a conductive material (e.g., a metal). The source and drain may be conductive and may include heavily doped, such as degenerate, semiconductor regions. The source and drain may be separated by a lightly doped semiconductor region or a channel. If the channel is n-type (i.e., the majority carriers are electrons), then the FET may be called an n-type FET. If the channel is p-type (i.e., the majority carriers are holes), then the FET may be called a p-type FET. The channel may be capped by an insulating gate oxide. The conductivity of the channel can be controlled by applying a voltage to the gate. For example, applying a positive or negative voltage to an n-type FET or a p-type FET, respectively, can cause the channel to become conductive. When a voltage greater than or equal to the transistor's threshold voltage is applied to the transistor's gate, the transistor may be "turned on" or "activated." If a voltage less than the transistor's threshold voltage is applied to the transistor's gate, then the transistor may be "turned off" or "deactivated."

[0161] The description herein, illustrated with reference to the accompanying drawings, describes exemplary configurations and does not represent all instances that can be implemented or that are within the scope of the claims. The term "exemplary" as used herein means "serving as an example, illustration, or description," not "preferred" or "superior to other instances." The detailed description includes specific details to provide an understanding of the described techniques. However, these techniques can be implemented without these specific details. In some cases, well-known structures and apparatus are shown in block diagram form to avoid obscuring the concepts of the described instances.

[0162] In the accompanying drawings, similar components or features may have the same reference numerals. Furthermore, various components of the same type can be distinguished by a hyphen following the reference numeral and a second numeral distinguishing them from each other. If only the first reference numeral is used in the specification, the description applies to any of the similar components having the same first reference numeral, regardless of the second reference numeral.

[0163] The functions described herein can be implemented in hardware, software executed by a processor, firmware, or any combination thereof. If implemented in software executed by a processor, these functions can be stored on or transmitted via a computer-readable medium as one or more instructions or code. Other examples and implementations are within the scope of this disclosure and the appended claims. For example, due to the nature of software, the above-described functions can be implemented using software executed by a processor, hardware, firmware, hardwiring, or any combination thereof. Features implementing the functions can also be physically located in various locations, including distributed configurations such that portions of the function are implemented in different physical locations.

[0164] For example, the various illustrative blocks and components described in connection with the disclosure herein may be implemented or executed using a general-purpose processor, DSP, ASIC, FPGA or other programmable logic device designed to perform the functions described herein, discrete gate or transistor logic, discrete hardware components or any combination thereof. A general-purpose processor may be a microprocessor, but alternatively, the processor may be any processor, controller, microcontroller or state machine. The processor may be implemented as a combination of computing devices (e.g., a combination of a DSP and a microprocessor, multiple microprocessors, a combination of one or more microprocessors with a DSP core, or any other such configuration).

[0165] As used herein, the word "or," as used in the claims, such as in a list of items (e.g., a list followed by phrases such as "at least one of" or "one or more of"), indicates a list containing endpoints such that a list of at least one of, for example, A, B, or C, means A or B or C or AB or AC or BC or ABC (i.e., A and B and C). Additionally, as used herein, the phrase "based on" should not be construed as referring to a closed set of conditions. For example, without departing from the scope of this disclosure, an exemplary step described as "based on condition A" may be based on both condition A and condition B. In other words, as used herein, the phrase "based on" should also be interpreted as the phrase "at least partially based on".

[0166] Computer-readable media includes both non-transitory computer-readable storage media and communication media, with communication media encompassing any media that facilitates the transfer of a computer program from one place to another. Non-transitory storage media can be any available media accessible by a general-purpose or special-purpose computer. By way of example, and not limitation, non-transitory computer-readable media may include RAM, read-only memory (ROM), electrically erasable programmable ROM (EEPROM), compressed optical disc (CD) ROM or other optical disc storage devices, magnetic disk storage devices or other magnetic storage devices, or any other non-transitory media that can be used to carry or store desired program code elements in the form of instructions or data structures and is accessible by a general-purpose or special-purpose computer or a general-purpose or special-purpose processor. Similarly, any connection is appropriately referred to as computer-readable media. For example, if software is transferred from a website, server, or other remote resource using coaxial cable, fiber optic cable, twisted pair, digital subscriber line (DSL), or technologies such as infrared, radio, and microwave, then coaxial cable, fiber optic cable, twisted pair, DSL, or technologies such as infrared, radio, and microwave are included in the definition of media. As used in this article, disks and optical discs include CDs, laser discs, optical discs, DVDs, floppy disks, and Blu-ray discs. Disks typically reproduce data magnetically, while optical discs reproduce data optically using lasers. Combinations of these are also included within the scope of computer-readable media.

[0167] The description provided herein enables those skilled in the art to make or use the invention. Various modifications to the invention will be apparent to those skilled in the art, and the general principles defined herein can be applied to other variations without departing from the scope of the invention. Therefore, this disclosure is not limited to the examples and designs described herein, but is given the widest scope consistent with the principles and novel features disclosed herein.

Claims

1. A semiconductor device comprising: Memory devices; and A controller, coupled to the memory device and configured such that the semiconductor device: Receive multiple read commands for accessing one or more memory cells in a memory array; For each of the plurality of read commands executed to access one or more memory cells of the first portion of the memory array, a counter is incremented according to a first granularity to track the number of read commands executed corresponding to the first portion of the memory array; Determine whether the number of executed read commands corresponding to the first portion of the memory array meets a threshold during a first duration. as well as The system switches from a first granularity to a second granularity, at least in part, based on the determination that the number of executed read commands corresponding to the first portion of the memory array meets the threshold during the first duration, in order to track the number of executed read commands corresponding to the first portion of the memory array.

2. The semiconductor device of claim 1, wherein the number of executed read commands corresponding to the first portion of the memory array satisfies the threshold during the first duration, based at least in part on the number of executed read commands exceeding a first threshold, and wherein the controller configured to cause the semiconductor device to switch from the first granularity to the second granularity is configured to cause the semiconductor device to: Increase the granularity for tracking the number of executed read commands corresponding to the first portion of the memory array.

3. The semiconductor device of claim 1, wherein the number of executed read commands corresponding to the first portion of the memory array satisfies the threshold during the first duration, at least in part based on the number of executed read commands being less than a second threshold, and wherein the controller configured to cause the semiconductor device to switch from the first granularity to the second granularity is configured to cause the semiconductor device to: Reduce the granularity used to track the number of executed read commands corresponding to the first portion of the memory array.

4. The semiconductor device of claim 1, wherein the controller configured to cause the semiconductor device to track the number of executed read commands corresponding to the first portion of the memory array according to the first granularity is configured to cause the semiconductor device to: The search for data in the counter corresponding to the first portion of the memory array is based at least in part on a read command among a plurality of read commands executed for accessing memory cells corresponding to the first portion of the memory array. The counter is incremented at least in part based on the execution of the read command.

5. The semiconductor device of claim 4, wherein the controller is further configured to cause the semiconductor device to: The data is updated at least in part based on the switching from the first granularity to the second granularity to track the number of executed read commands corresponding to the first portion of the memory array.

6. The semiconductor device of claim 5, wherein the controller configured to cause the semiconductor device to update the data is configured to cause the semiconductor device to: At least in part, based on the switch from the first granularity to the second granularity and the fact that the second granularity is larger than the first granularity, one or more additional nodes are added to the data; or One or more nodes are removed from the data, at least in part based on the switching from the first granularity to the second granularity and the fact that the first granularity is greater than the second granularity.

7. The semiconductor device of claim 4, wherein the controller is further configured to cause the semiconductor device to: The data, the counter, or both are stored at the memory system controller of the memory system.

8. The semiconductor device of claim 1, wherein the controller is further configured to cause the semiconductor device to: Based at least in part on the switching from the first granularity to the second granularity and the fact that the second granularity is greater than the first granularity, a plurality of second number of executed read commands corresponding to the respective sub-parts of the first portion of the memory array are tracked according to the second granularity.

9. The semiconductor device of claim 8, wherein the controller is further configured to cause the semiconductor device to: At least in part, based on the switching from the first granularity to the second granularity and the fact that the second granularity is greater than the first granularity, a plurality of second counters corresponding to a plurality of second number of executed read commands are activated.

10. The semiconductor device of claim 1, wherein the controller is further configured to cause the semiconductor device to: The counter for the number of read commands executed is deactivated, based at least in part on the switching from the first granularity to the second granularity and the fact that the first granularity is greater than the second granularity.

11. The semiconductor device of claim 1, wherein the controller is further configured to cause the semiconductor device to: A read interference remedy is performed on the first portion of the memory array, at least in part, based on the determination that the number of executed read commands corresponding to the first portion of the memory array meets the threshold during the first duration.

12. The semiconductor device of claim 1, wherein the controller is further configured to cause the semiconductor device to: Maintain the real-time clock; and Using the real-time clock to identify that the first duration has elapsed, wherein the controller configured to cause the semiconductor device to determine whether the number of executed read commands corresponding to the first portion of the memory array meets the threshold during the first duration is configured to cause the semiconductor device to trigger the determination of whether the number of executed read commands corresponding to the first portion of the memory array meets the threshold during the first duration, at least in part based on the identification that the first duration has elapsed.

13. The semiconductor device of claim 1, wherein the first granularity includes memory array level granularity, virtual block level granularity, block level granularity, page level granularity, page line group level granularity, or word line level granularity, and the second granularity is different from the first granularity and includes memory array level granularity, virtual block level granularity, block level granularity, page level granularity, page line group level granularity, or word line level granularity.

14. The semiconductor device of claim 1, wherein the threshold, the first duration, or both are at least partially based on the refresh cycle of the memory array, a read threshold for retiring data from the memory array, or both.

15. A semiconductor device comprising: Memory devices; and A controller, coupled to the memory device and configured such that the semiconductor device: Receive multiple read commands for accessing one or more memory cells in a memory array; The number of executed read commands corresponding to a first portion of the memory array is tracked according to a first granularity, the tracking being at least in part based on the number of the plurality of read commands executed; Determine whether the number of executed read commands corresponding to the first portion of the memory array meets a threshold during a first duration. The system switches from a first granularity to a second granularity, at least in part, based on the determination that the number of executed read commands corresponding to the first portion of the memory array meets the threshold during the first duration, in order to track the number of executed read commands corresponding to the first portion of the memory array. Based at least in part on the switching from the first granularity to the second granularity and the fact that the second granularity is greater than the first granularity, a plurality of second number of executed read commands corresponding to the respective sub-parts of the first portion of the memory array are tracked according to the second granularity; Determine whether a second number of the plurality of second numbers of executed read commands corresponding to a respective sub-part of the first portion of the memory array satisfies a second threshold during a second duration; as well as At least in part, based on determining that the second number of the plurality of second number of executed read commands corresponding to the respective sub-parts of the first portion of the memory array satisfies the second threshold during the second duration, the process switches from the second granularity to a third granularity for tracking the second number of the plurality of second number of executed read commands corresponding to the respective sub-parts of the first portion of the memory array.

16. A semiconductor device comprising: Memory devices; and A controller, coupled to the memory device and configured such that the semiconductor device: Receive multiple read commands for accessing one or more memory cells in a memory array; The number of executed read commands corresponding to a first portion of the memory array is tracked according to a first granularity, the tracking being at least in part based on the number of the plurality of read commands executed; Determine whether the number of executed read commands corresponding to the first portion of the memory array meets a threshold during a first duration. The system switches from a first granularity to a second granularity, at least in part, based on the determination that the number of executed read commands corresponding to the first portion of the memory array meets the threshold during the first duration, in order to track the number of executed read commands corresponding to the first portion of the memory array. Based at least in part on the switching from the first granularity to the second granularity and the fact that the second granularity is greater than the first granularity, a plurality of second number of executed read commands corresponding to the respective sub-parts of the first portion of the memory array are tracked according to the second granularity; Determine whether a second number of the plurality of second numbers of executed read commands corresponding to a respective sub-part of the first portion of the memory array satisfies a second threshold during a second duration; as well as At least in part, based on the determination that the second number of the plurality of second number of executed read commands corresponding to the respective sub-parts of the first portion of the memory array failed to meet the second threshold during the second duration, a second granularity switch is avoided from tracking the second number of the plurality of second number of executed read commands corresponding to the respective sub-parts of the first portion of the memory array.

17. The semiconductor device of claim 16, wherein the controller is further configured to cause the semiconductor device to: At least in part, based on the determination that the second number of the plurality of second number of executed read commands corresponding to the respective sub-parts of the first portion of the memory array failed to meet the second threshold during the second duration, the second counter indicating the second number of the plurality of second number of executed read commands is reset.

18. A non-transitory computer-readable medium storing code, the code comprising instructions that, when executed by a processor of an electronic device, cause the electronic device to: Receive multiple read commands for accessing one or more memory cells in a memory array; For each of the plurality of read commands executed to access one or more memory cells of the first portion of the memory array, a counter is incremented according to a first granularity to track the number of read commands executed corresponding to the first portion of the memory array; Determine whether the number of executed read commands corresponding to the first portion of the memory array meets a threshold during a first duration. as well as The system switches from a first granularity to a second granularity, at least in part, based on the determination that the number of executed read commands corresponding to the first portion of the memory array meets the threshold during the first duration, in order to track the number of executed read commands corresponding to the first portion of the memory array.

19. The non-transitory computer-readable medium of claim 18, wherein at least in part based on the number of executed read commands exceeding a first threshold, the number of executed read commands corresponding to the first portion of the memory array satisfies the threshold during the first duration, and wherein the instruction causing the electronic device to switch from the first granularity to the second granularity, when executed by the processor of the electronic device, causes the electronic device to: Increase the granularity for tracking the number of executed read commands corresponding to the first portion of the memory array.

20. A method executed by a memory system, comprising: Receive multiple read commands for accessing one or more memory cells in a memory array; For each of the plurality of read commands executed to access one or more memory cells of the first portion of the memory array, a counter is incremented according to a first granularity to track the number of read commands executed corresponding to the first portion of the memory array; Determine whether the number of executed read commands corresponding to the first portion of the memory array meets a threshold during a first duration. as well as The system switches from a first granularity to a second granularity, at least in part, based on the determination that the number of executed read commands corresponding to the first portion of the memory array meets the threshold during the first duration, in order to track the number of executed read commands corresponding to the first portion of the memory array.

Citation Information

Patent Citations

  • Method of detecting read hotness and degree of randomness in solid-state drives (SSDS)

    US20200393974A1