Accumulated memory temperature readings accessible in the memory subsystem

Abstract

A memory subsystem is disclosed that generates accessible cumulative memory temperature statistics relative to a target memory portion. This may be accomplished by maintaining one or more hold variables and one or more accumulation variables. The accumulation variables may be updated iteratively upon, for example, expiration of a timer or triggering of an I / O event. Updating the accumulation variables may include obtaining a current temperature and tracking one or more of the following in the iteration: a maximum value, a minimum value, and an average temperature. The accumulation value may track how many times the accumulation variable has been updated. When the accumulation value reaches an accumulation action threshold, the current state of the accumulation variable may be used to update the hold variable. The accumulation value and accumulation variables may then be reset and used to accumulate additional temperature statistics.

Description

Technical Field

[0001] The present disclosure relates generally to a memory subsystem, and more particularly to generating accessible cumulative memory temperature readings in a memory subsystem. Background Art

[0002] The memory subsystem may be a storage system, such as a solid-state drive (SSD), and may include one or more memory components that store data. The memory components may be, for example, non-volatile memory components and volatile memory components. Generally speaking, a host system may utilize the memory subsystem to store data in the memory components and retrieve data from the memory components. Summary of the Invention

[0003] In one aspect, the present application provides a method of operating a memory device, comprising: iterating a set of operations to update one or more accumulation variables corresponding to a target memory portion until a value reaches a cumulative action limit threshold; and in response to the value reaching the cumulative action limit threshold, updating one or more retention variables based on the updated one or more accumulation variables, wherein the set of operations comprises: obtaining one or more temperature measurement values ​​corresponding to the target memory portion in response to detecting a temperature accumulation trigger event; updating the one or more accumulation variables based on the one or more temperature measurement values; and updating the values ​​to compare with the cumulative action limit threshold.

[0004] In another aspect, the present application provides a computer-readable storage medium storing instructions that, when executed by a computing system, cause the computing system to perform operations, the operations comprising: iterating a set of operations to update one or more accumulation variables corresponding to a target memory portion until a value reaches a cumulative action limit threshold; and in response to the value reaching the cumulative action limit threshold, updating one or more retention variables based on the updated one or more accumulation variables, wherein the set of operations comprises: obtaining one or more temperature measurement values ​​corresponding to the target memory portion in response to detecting a temperature accumulation trigger event; updating the one or more accumulation variables based on the one or more temperature measurement values; and updating the values ​​for comparison with the cumulative action limit threshold.

[0005] On the other hand, the present application provides a memory system comprising: a memory component comprising a target memory portion; and a processing device operably coupled to the memory component, the processing device being configured to: iterate a set of operations to update one or more accumulation variables corresponding to the target memory portion until a value reaches a cumulative action limit threshold; and in response to the value reaching the cumulative action limit threshold, update one or more retention variables based on the updated one or more accumulation variables, wherein the set of operations comprises: in response to detecting a temperature accumulation trigger event, obtaining one or more temperature measurement values ​​corresponding to the target memory portion; updating the one or more accumulation variables based on the one or more temperature measurement values; and updating the value to compare with the cumulative action limit threshold. BRIEF DESCRIPTION OF THE DRAWINGS

[0006] The present disclosure will be more fully understood from the detailed description provided below and the accompanying drawings of various embodiments of the present disclosure.

[0007] Figure 1 An example computing environment including a memory subsystem according to some embodiments of the present disclosure is described.

[0008] Figure 2A and 2B is a flow chart of accumulating temperature statistics with respect to a target memory portion according to some embodiments of the present disclosure.

[0009] Figure 3 is a flow chart of obtaining subsequent temperature measurements to update accumulated temperature statistics according to some embodiments of the present disclosure.

[0010] Figure 4 is a block diagram of an example computer system in which embodiments of the present disclosure may operate. DETAILED DESCRIPTION

[0011] Aspects of the present disclosure relate to accumulating temperature statistics for a memory subsystem that are accessible in real time. As used herein, the term "real time" is used to indicate an event that occurs close in time to its cause, e.g., without unnecessary delay. For example, a set of accumulated temperature statistics is available in "real time" because it can be retrieved by a user or analyzed by another process immediately after the temperature is acquired and stored.

[0012] In various embodiments, the memory statistics may include one or more of individual temperature measurements, maximum temperature, minimum temperature, average temperature, or deviations in temperature measurements. The memory subsystem is also referred to below as a "memory device." An example of a memory subsystem is a storage system, such as a solid-state drive (SSD). In some embodiments, the memory subsystem is a hybrid memory / storage subsystem. In various embodiments, the memory subsystem may include a non-volatile memory device, such as a NAND (NAND). Typically, a host system may utilize a memory subsystem that includes one or more memory components. The host system may provide data for storage at the memory subsystem and may request retrieval of data from the memory subsystem.

[0013] In conventional memory systems, temperature measurements are not performed consistently. For example, in some NAND devices, temperature measurements may be taken in response to NAND events such as reads or writes, but periods without such events may result in a lack of temperature data points. In such cases, temperature statistics may not reflect a complete picture of the memory system and may not be up-to-date. Furthermore, in conventional systems, operations related to temperature measurement are the responsibility of the memory system controller. This increases the load on the system controller and limits the ability of memory components to implement their own thermal compensation algorithms.

[0014] Aspects of the present disclosure address the above and other deficiencies by continuously accumulating temperature statistics for a NAND die or other target memory portion. Memory statistics accumulation may begin when the target memory portion is powered on or reset. Continuously accumulated temperature statistics may be updated using new temperature measurements taken in response to a timer or event on the target memory portion. This approach enables complete and up-to-date temperature measurement statistics to be maintained. In some embodiments, the target memory portion controller may be responsible for identifying opportunities to take temperature measurements and incorporating the temperature measurements into the accumulated statistics. By shifting responsibility for this function to the target memory portion (e.g., NAND die), this reduces the load on the memory system controller.

[0015] Figure 1An example computing environment 100 including a memory subsystem 110 according to some embodiments of the present disclosure is described. Memory subsystem 110 may include media, such as memory components 112A through 112N. Memory components 112A through 112N may be volatile memory components, non-volatile memory components, or a combination of such components. In some embodiments, the memory subsystem is a storage system. An example of a storage system is an SSD. In some embodiments, memory subsystem 110 is a hybrid memory / storage subsystem. Generally speaking, computing environment 100 may include a host system 120 that utilizes memory subsystem 110. For example, host system 120 may write data to and read data from memory subsystem 110.

[0016] Host system 120 may be a computing device, such as a desktop computer, laptop computer, network server, mobile device, or any other computing device that includes memory and processing devices. Host system 120 may include or be coupled to memory subsystem 110, such that host system 120 can read data from or write data to memory subsystem 110. Host system 120 may be coupled to memory subsystem 110 via a physical host interface. As used herein, "coupled to" generally refers to a connection between components, which may be an indirect communication connection or a direct communication connection (e.g., without intervening components), whether wired or wireless, including connections such as electrical, optical, magnetic, and the like. Examples of physical host interfaces include, but are not limited to, a Serial Advanced Technology Attachment (SATA) interface, a Peripheral Component Interconnect Express (PCIe) interface, a Universal Serial Bus (USB) interface, Fibre Channel, Serial Attached SCSI (SAS), and the like. The physical host interface may be used to transfer data between host system 120 and memory subsystem 110. When the memory subsystem 110 is coupled to the host system 120 via a PCIe interface, the host system 120 may further utilize an NVM Express (NVMe) interface to access the memory components 112A to 112N. A physical host interface may provide an interface for passing control, address, data, and other signals between the memory subsystem 110 and the host system 120.

[0017] Memory components 112A-112N may include any combination of different types of nonvolatile memory components and / or volatile memory components. An example of a nonvolatile memory component includes non-AND (NAND) type flash memory. Each of memory components 112A-112N may include one or more arrays of memory cells, such as single-level cells (SLC) or multi-level cells (MLC) (e.g., triple-level cells (TLC) or quad-level cells (QLC)). In some embodiments, a particular memory component may include both an SLC portion and an MLC portion of memory cells. Each of the memory cells may store one or more data bits (e.g., a block of data) used by host system 120. Although nonvolatile memory components such as NAND-type flash memory are described, memory components 112A-112N may be based on any other type of memory, such as volatile memory. In some embodiments, memory components 112A-112N may be, but are not limited to, random access memory (RAM), read-only memory (ROM), dynamic random access memory (DRAM), synchronous dynamic random access memory (SDRAM), phase change memory (PCM), magnetic random access memory (MRAM), or non-volatile (NOR) flash memory, electrically erasable programmable read-only memory (EEPROM), and a cross-point array of non-volatile memory cells. A cross-point array of non-volatile memory can be combined with a stackable cross-grid data access array to perform bit storage based on changes in bulk resistance. In addition, compared to many flash-based memories, cross-point non-volatile memory can perform write-in-place operations, where non-volatile memory cells can be programmed without first erasing the non-volatile memory cells. Furthermore, the memory cells of memory components 112A-112N can be grouped into memory pages or data blocks, which can refer to the cells of a memory component used to store data.

[0018] A memory system controller 115 (hereinafter referred to as the "controller") can communicate with memory components 112A-112N to perform operations, such as reading, writing, or erasing data at memory components 112A-112N, as well as other such operations. Controller 115 may include hardware, such as one or more integrated circuits and / or discrete components, buffer memory, or a combination thereof. Controller 115 may be a microcontroller, dedicated logic circuitry (e.g., a field programmable gate array (FPGA), an application-specific integrated circuit (ASIC), etc.), or other suitable processor. Controller 115 may include a processor (e.g., a processing device) 117 configured to execute instructions stored in local memory 119. In the illustrated example, local memory 119 of controller 115 includes embedded memory configured to store instructions for executing various processes, operations, logic flows, and routines that control the operation of memory subsystem 110, including handling communications between memory subsystem 110 and host system 120. In some embodiments, local memory 119 may include memory registers that store memory pointers, fetched data, and the like. Local memory 119 may also include read-only memory (ROM) for storing microcode. Figure 1 The example memory subsystem 110 in FIG. 1 is illustrated as including a controller 115, but in another embodiment of the present disclosure, the memory subsystem 110 may not include a controller 115 and may instead rely on external control (e.g., provided by an external host or by a processor or controller separate from the memory subsystem).

[0019] In general, the controller 115 may receive commands or operations from the host system 120 and convert the commands or operations into instructions or appropriate commands to achieve the desired access to the memory components 112A to 112N. The controller 115 may be responsible for other operations such as wear leveling operations, garbage collection operations, error detection and error correction code (ECC) operations, encryption operations, cache operations, and address translation between logical block addresses and physical block addresses associated with the memory components 112A to 112N. The controller 115 may further include host interface circuitry to communicate with the host system 120 via a physical host interface. The host interface circuitry may convert commands received from the host system into command instructions to access the memory components 112A to 112N, and convert responses associated with the memory components 112A to 112N into information for the host system 120.

[0020] The memory subsystem 110 may also include additional circuits or components not illustrated. In some embodiments, the memory subsystem 110 may include a cache or buffer (e.g., DRAM) and address circuits (e.g., row decoders and column decoders) that receive addresses from the controller 115 and decode the addresses to access the memory components 112A to 112N.

[0021] Memory subsystem 110 includes a temperature accumulator 113 that can be used to trigger temperature measurements and accumulate them into temperature statistics. In some embodiments, controller 115 includes at least a portion of temperature accumulator 113. In some embodiments, memory components 112A-112N may include processing that includes at least a portion of temperature accumulator 113. For example, controller 115 may include a processor 117 (processing device) configured to execute instructions stored in local memory 119 for performing the operations described herein. In some embodiments, temperature accumulator 113 is part of host system 120, an application, or an operating system.

[0022] The temperature accumulator 113 can maintain a set of retained variables that accumulate memory statistics for the memory components 112A to 112N of the memory subsystem 110. After powering on or resetting a memory component, the temperature accumulator 113 can record initial temperature measurements in the retained variables of the individual memory components. The temperature accumulator 113 can further maintain timers and event values ​​(e.g., counters) for each memory component. When a timer or event value reaches a threshold, the temperature accumulator 113 can obtain a temperature measurement and use it to update the accumulated temperature measurement in the retained variables. For example, the temperature accumulator 113 can track the maximum temperature, minimum temperature, temperature deviation, average temperature, or any combination thereof. Additional details regarding the operation of the temperature accumulator 113 are described below.

[0023] Figure 2A and 2B is a flow chart of an example method 200 for accumulating temperature statistics with respect to a target memory portion according to some embodiments of the present technology. The method 200 may be performed by processing logic that may include hardware (e.g., a processing device, circuitry, dedicated logic, programmable logic, microcode, hardware of a device, integrated circuit, etc.), software (e.g., instructions running or executed on a processing device), or a combination thereof. In some embodiments, the method 200 is performed by Figure 1The temperature accumulator 113 is executed. Although shown in a specific sequence or order, the order of the processes may be modified unless otherwise specified. Therefore, it should be understood that the illustrated embodiments are merely examples, and the illustrated processes may be performed in a different order, and some processes may be performed in parallel. In addition, one or more processes may be omitted in various embodiments. Therefore, not all processes are required in every embodiment. Other process flows are also possible.

[0024] In some embodiments, processing logic may be executed relative to a target memory portion, such as one or more memory systems (e.g., NAND devices), one or more dies (e.g., NAND dies) within a memory system, one or more blocks of a die, one or more pages of a die, and the like. In some embodiments where processing logic is executed relative to a target memory portion of a die (e.g., a NAND die), the processing logic may be executed by the die's controller, thereby reducing the load that may otherwise fall on the system controller for recording temperatures and calculating temperature statistics for each memory portion. In some embodiments, processing logic may be initiated when the memory portion is powered on or reset. At block 204, processing logic may perform a characteristic temperature read on the target memory portion. A characteristic temperature read is any action that produces a temperature reading. In some embodiments, the target memory portion records temperature upon certain events, such as during the execution of an I / O event. In some embodiments, processing logic may use a "get" I / O event to cause a temperature reading of the target memory portion.

[0025] At block 206, the processing logic may store the temperature measurement in one or more hold variables accessible to the processing logic. In various embodiments, the hold variables may correspond to registers in a memory system, other designated memory spaces, or to variables in a program that may be stored in various system memory resources. As used herein, the processing logic may gain access to the variables in various ways, such as by loading to and from registers, reading and setting named variables in a memory stack, reading and writing to a specific memory address, and the like. In some embodiments, the hold variables may store one or more temperature statistics, such as a maximum temperature, a minimum temperature, a median temperature, an average temperature, or a variance of recorded temperatures. In some embodiments, the hold variables may store histogram data for the temperature readings observed to date by the processing logic.

[0026] At block 208, processing logic may access or reset an accumulation variable. Similar to a hold variable, in various embodiments, an accumulation variable may correspond to a register in a memory system, other designated memory space, or to a variable in a program that may be stored in various system memory resources. The accumulation variable may store temperature statistics to be used by block 210 until the amount of the accumulation action reaches the accumulation action limit threshold. In some embodiments, the accumulation variable and the hold variable are floating-point variables. At block 208, the accumulation variable is reset (e.g., cleared, set to 0, etc.) so that the accumulation variable can begin accumulating new temperature statistics based on further accumulation action updates. If processing logic reaches block 208 for the first time, processing logic may also obtain access to the accumulation action value and initialize the accumulation action value (e.g., set it to zero to increment and compare with the accumulation action limit threshold, or set it to the value of the accumulation action limit threshold to decrement and compare with zero).

[0027] At block 209, processing logic may accumulate temperature measurements. Accumulating temperature measurements may include performing iterations until the accumulated action value reaches a limit. Each iteration may include waiting until an accumulation trigger position occurs, and in response, obtaining a temperature measurement and using it to update an accumulation variable. When the accumulated action value reaches a limit, the accumulation variable may be used to update a hold variable. Figure 2B and Figure 3 Provides additional details about the accumulated temperature measurements.

[0028] At block 216, processing logic may reset the accumulated action value. For example, processing logic may set the accumulated action counter to zero to increment and compare to the accumulated action limit threshold at block 213, or set the accumulated action counter to the value of the accumulated action limit threshold to decrement at block 213.

[0029] Figure 2B Additional details are provided regarding the operations performed by the processing logic at block 209 in some embodiments. At block 210, the processing logic may detect a cumulative triggering event. In various embodiments, the cumulative action triggering event may be when a timer reaches a threshold, when an event counter threshold is reached, or when a timer or event counter threshold is reached.

[0030] Processing logic may obtain a temperature measurement at block 211. In various embodiments, the temperature measurement may be obtained by reading a stored temperature measurement automatically obtained as part of an accumulation action triggering event, or by causing an I / O event, such as a read or get operation, to be performed on the target memory portion that may include obtaining a temperature measurement.

[0031] At block 212, processing logic may update a set of accumulation variables using the obtained temperature measurements. The accumulation variables may be updated to track one or more of the following: maximum temperature, minimum temperature, average temperature, temperature deviation, or any combination thereof. Figure 3 Additional details regarding detecting an accumulation trigger event (block 210 ), obtaining a temperature measurement (block 211 ), and updating an accumulation variable (block 212 ) are discussed in greater detail.

[0032] At block 213, processing logic may update the cumulative action value (e.g., by incrementing the cumulative action value to compare to a cumulative action limit threshold, decrementing the cumulative action value to compare to zero, etc.). At block 214, processing logic may determine whether the cumulative action limit threshold has been reached based on the cumulative action value. In some embodiments, the cumulative action limit may be a programmable value set by a user.

[0033] At block 215, processing logic may update the statistics in the holding variable with the statistics accumulated in the accumulation variable. In some embodiments, each time processing logic reaches block 215, the holding variable may store a record of all accumulation variable values, such as in a log. In some embodiments, the holding variable may combine some or all accumulation variable values, such as to track overall statistics, such as the highest and lowest temperatures of the target memory portion. After block 215, the temperature measurements have been accumulated (e.g., block 209 has been completed), and processing logic may continue to Figure 2A Frame 216.

[0034] Through various iterations of blocks 206-216, the processing logic may generate statistics for the target memory portion. These statistics may be used in various processes to adjust operating parameters of the target memory portion of the memory system to improve reliability or performance, to input into the design process, to ensure adherence to operating guidelines, to control individual thermal compensation algorithms, etc.

[0035] Figure 3 is a flow chart of an example method 300 for obtaining subsequent temperature measurements to update accumulated temperature statistics according to some embodiments of the present technology. Figure 2B 2. The method 300 may be performed by processing logic that may include hardware (e.g., a processing device, circuitry, dedicated logic, programmable logic, microcode, hardware of a device, an integrated circuit, etc.), software (e.g., instructions running or executed on a processing device), or a combination thereof. In some embodiments, the method 300 may be performed by processing logic that may include hardware (e.g., a processing device, circuitry, dedicated logic, programmable logic, microcode, hardware of a device, an integrated circuit, etc.), software (e.g., instructions running or executed on a processing device), or a combination thereof. Figure 1The temperature accumulator 113 is executed. Although shown in a specific sequence or order, the order of the processes may be modified unless otherwise specified. Therefore, it should be understood that the illustrated embodiments are merely examples, and the illustrated processes may be performed in a different order, and some processes may be performed in parallel. In addition, one or more processes may be omitted in various embodiments. Therefore, not all processes are required in every embodiment. Other process flows are also possible.

[0036] The processing logic of method 300 may be initiated at block 302 when the processing logic recognizes that a timer has reached a threshold, or at block 304 when the processing logic recognizes that an event has occurred. An "event" may be any of a variety of triggers, such as a read, write, get, or other I / O operation performed on the target memory portion. In some embodiments, an event may be other actions that result in a certain temperature being reached on the target memory portion. In some embodiments, the processing logic is triggered only in response to a timer or only in response to an event. In some embodiments, when the processing logic is triggered, the timer is paused and new events will not trigger the processing logic until the timer is reset and events are enabled at block 322. In some embodiments, an instance of the processing logic may be triggered by either the expiration of a timer or the occurrence of an event, regardless of when either occurred last. In some embodiments, the processing logic of method 300 may be part of the processing logic of method 200 and may use an accumulation variable accessed by the processing logic of method 200 at block 208.

[0037] At block 306, processing logic may perform a characteristic temperature read, for example, by causing a get operation on the target memory portion. The get operation may cause a temperature measurement to be obtained, and processing logic may access this temperature measurement and use it as the current temperature.

[0038] At block 308, processing logic has identified the event at block 304. This event may have triggered an automated process that recorded one or more temperature measurements, which processing logic can access and use as the current temperature. If the event has not triggered a temperature measurement, processing logic can continue to block 306.

[0039] At block 310, processing logic may determine whether the current temperature is below a stored minimum temperature. For example, processing logic may compare the current temperature to a minimum temperature stored in one of the accumulation variables. If the current temperature is below the stored minimum temperature, process 300 continues to block 312. Otherwise, process 300 continues to block 314.

[0040] At block 312, processing logic may replace the stored minimum temperature with the current temperature. For example, processing logic may replace the minimum temperature stored in one of the accumulation variables with the current temperature.

[0041] At block 314, processing logic may determine whether the current temperature is higher than the stored maximum temperature. For example, processing logic may compare the current temperature to the maximum temperature stored in one of the accumulation variables. If the current temperature is higher than the stored maximum temperature, process 300 continues to block 316. Otherwise, process 300 continues to block 318.

[0042] At block 316, processing logic may replace the stored maximum temperature with the current temperature. For example, processing logic may replace the maximum temperature stored in one of the accumulation variables with the current temperature.

[0043] At block 318, processing logic may update the stored variance of the measured temperature with the current temperature. For example, processing logic may replace the stored standard deviation accumulation variable with the new standard deviation that accounts for the current temperature.

[0044] At block 320, processing logic may update the stored average temperature using the current temperature. For example, processing logic may replace the stored average accumulation variable with the new average value that represents the current temperature. More specifically, the new average value may be calculated using the formula: m = (c + n * s) / (n + 1), where m is the new average temperature, n is the number of temperature measurements used to generate the stored average value, and c is the current temperature.

[0045] In some embodiments, the processing logic may also store additional data. For example, each temperature reading may be associated with a timestamp or other metadata. In some embodiments, all temperature readings may be stored. In some embodiments, all temperature readings within the most recent time window may be stored. In some embodiments, the granularity of stored temperature readings may increase as the temperature is updated. For example, all temperature readings within the last ten minutes may be stored, but only one temperature reading may be stored for every preceding 10 seconds, or an average of the temperature readings may be stored for every preceding 10-second period. In some embodiments, any of the temperature statistics may be stored as a histogram of the readings.

[0046] At block 322 , in an embodiment where processing logic has paused the timer for block 302 and does not identify events for block 304 , processing logic may reset and resume the timer and resume identifying events, thereby allowing a new instance of processing logic for method 300 to be triggered.

[0047] Figure 4 An example machine illustrating a computer system 400 may execute a set of instructions within the computer system for causing the machine to perform any one or more of the methodologies discussed herein. In some embodiments, the computer system 400 may correspond to a host system (e.g., Figure 1 120) that includes, is coupled to, or utilizes a memory subsystem (e.g., Figure 1 memory subsystem 110) or can be used to perform operations of the controller (for example, execute an operating system to perform operations corresponding to Figure 1 In some embodiments, the machine may be connected (e.g., using a network) to other machines. The machine may operate in the capacity of a server or a client machine in a client-server network environment, or as a peer machine in a peer-to-peer (or distributed) network environment, or as a server or a client machine in a cloud computing infrastructure or environment.

[0048] The machine may be a personal computer (PC), a tablet PC, a set-top box (STB), a personal digital assistant (PDA), a cellular phone, a network appliance, a server, a network router, a switch or a bridge, or any machine capable of executing (sequentially or otherwise) a set of instructions that specify actions to be taken by the machine. Further, while a single machine is described, the term "machine" shall also be taken to include any collection of machines that individually or collectively execute one (or more) sets of instructions to perform any one or more of the methodologies discussed herein.

[0049] The example computer system 400 includes a processing device 402, a main memory 404 (e.g., read-only memory (ROM), flash memory, dynamic random access memory (DRAM), such as synchronous DRAM (SDRAM) or Rambus DRAM (RDRAM)), etc.), a static memory 406 (e.g., flash memory, static random access memory (SRAM), etc.), and a data storage system 418, which communicate with each other via a bus 430.

[0050] Processing device 402 represents one or more general-purpose processing devices, such as a microprocessor, a central processing unit, or the like. More specifically, the processing device may be a complex instruction set computing (CISC) microprocessor, a reduced instruction set computing (RISC) microprocessor, a very long instruction word (VLIW) microprocessor, or a processor that implements other instruction sets, or a combination of instruction sets. Processing device 402 may also be one or more special-purpose processing devices, such as an application-specific integrated circuit (ASIC), a field-programmable gate array (FPGA), a digital signal processor (DSP), a network processor, or the like. Processing device 402 is configured to execute instructions 426 for performing the operations discussed herein. Computer system 400 may further include a network interface device 408 for communicating over a network 420.

[0051] The data storage system 418 may include a machine-readable storage medium 424 (also referred to as a computer-readable medium) having stored thereon one or more sets of instructions 426 or software embodying any one or more of the methodologies or functions described herein. The instructions 426 may also reside, completely or at least partially, within the main memory 404 and / or within the processing device 402 during execution thereof by the computer system 400, with the main memory 404 and the processing device 402 also constituting machine-readable storage media. The machine-readable storage medium 424, the data storage system 418, and / or the main memory 404 may correspond to Figure 1 Memory subsystem 110.

[0052] In one embodiment, instructions 426 include instructions for implementing and responding to a timer or event (e.g., Figure 1 The temperature accumulator 113 of the memory portion is used to continuously accumulate temperature statistics corresponding to the function of the memory portion. Although the machine-readable storage medium 424 is shown as a single medium in the example embodiment, the term "machine-readable storage medium" should be considered to include a single medium or multiple media that store one or more sets of instructions. The term "machine-readable storage medium" should also be considered to include any medium that can store or encode a set of instructions for execution by a machine and cause the machine to perform any one or more of the methods of the present disclosure. Therefore, the term "machine-readable storage medium" should be considered to include, but not be limited to, solid-state memory, optical media, and magnetic media.

[0053] Some portions of the previous detailed description have been presented in terms of algorithms and symbolic representations of operations on data bits within a computer memory. These algorithmic descriptions and representations are the means by which those skilled in the art of data processing most effectively convey the substance of their work to others skilled in the art. An algorithm is herein and generally conceived of as a self-consistent sequence of steps that produces a desired result. An operation is one that requires physical manipulation of physical quantities. Typically (but not necessarily), these quantities take the form of electrical or magnetic signals capable of being stored, combined, compared, and otherwise manipulated. It has proven convenient at times, primarily for common reasons, to refer to these signals as bits, values, elements, symbols, characters, terms, numbers, or the like.

[0054] It should be borne in mind, however, that all of these and similar terms are to be associated with the appropriate physical quantities and are merely convenient labels applied to these quantities. The present disclosure may refer to the actions and processes of a computer system or similar electronic computing device to control and transform data represented as physical (electronic) quantities within the computer system's registers and memories into other data similarly represented as physical quantities within the computer system's memories or registers or other such information storage systems.

[0055] The present disclosure also relates to an apparatus for performing the operations described herein. This apparatus may be specially constructed for the required purposes, or it may comprise a general-purpose computer selectively activated or reconfigured by a computer program stored in the computer. This computer program may be stored in a computer-readable storage medium, such as, but not limited to, any type of disk, including floppy disks, optical disks, CD-ROMs and magneto-optical disks, read-only memory ("ROM"), random access memory ("RAM"), EPROM, EEPROM, magnetic or optical cards, or any other type of medium suitable for storing electronic instructions and each coupled to a computer system bus.

[0056] The algorithms and displays presented herein are not inherently related to any particular computer or other device. Various general-purpose systems may be used with programs according to the teachings herein, or it may prove convenient to construct more specialized devices for performing the methods. The structures of various such systems will be presented as set forth in the description below. Additionally, the present disclosure is not described with reference to any particular programming language. It will be appreciated that the teachings of the present disclosure as described herein may be implemented using a variety of programming languages.

[0057] The present disclosure may be provided as a computer program product or software, which may include a machine-readable medium having stored thereon instructions that can be used to program a computer system (or other electronic device) to perform processes according to the present disclosure. A machine-readable medium includes any mechanism for storing information in a form readable by a machine (e.g., a computer). In some embodiments, a machine-readable (e.g., computer-readable) medium includes a machine (e.g., computer) readable storage medium, such as a read-only memory ("ROM"), a random access memory ("RAM"), a magnetic disk storage medium, an optical storage medium, a flash memory component, or the like.

[0058] In the foregoing description, embodiments of the present disclosure have been described with reference to specific example embodiments thereof. It will be apparent that various modifications may be made thereto without departing from the broader spirit and scope of the embodiments of the present disclosure as set forth in the appended claims. The specification and drawings are, therefore, to be regarded in an illustrative rather than a restrictive sense.

[0059] It will be appreciated by those skilled in the art that the above-described Figures 1 to 4 For example, the order of the logic may be rearranged, sub-steps may be performed in parallel, illustrated logic may be omitted, other logic may be included, etc. In some implementations, one or more of the components described above may perform one or more of the processes described below.

[0060] References in this specification to "embodiments" (e.g., "some embodiments," "various embodiments," "one embodiment," "an embodiment," etc.) mean that a particular feature, structure, or characteristic described in connection with the embodiment is included in at least one embodiment of the present disclosure. The appearance of these phrases in various places in the specification does not necessarily all refer to the same embodiment, nor are separate or alternative embodiments mutually exclusive of other embodiments. In addition, various features are described that may be present in some embodiments but not in others. Similarly, various requirements are described that may be requirements for some embodiments but not for others.

[0061] As used herein, above a threshold value means that the value of the item being compared is higher than another specified value, the item being compared is among a specified number of items with a maximum value, or the item being compared has a value within a specified top percentage value. As used herein, below a threshold value means that the value of the item being compared is lower than another specified value, the item being compared is among a specified number of items with a minimum value, or the item being compared has a value within a specified bottom percentage value. As used herein, within a threshold value means that the value of the item being compared is between two specified other values, the item being compared is among an intermediate specified number of items, or the item being compared has a value within an intermediate specified percentage range. Relative terms such as high or unimportant, when not otherwise defined, can be understood as assigning a value and determining how the value will compare with an established threshold value. For example, the phrase "selecting a fast connection" can be understood to mean selecting a connection with a value assigned above a threshold value corresponding to its connection speed.

[0062] As used herein, the word "or" refers to any possible permutation of a group of items. For example, the phrase "A, B, or C" refers to at least one of A, B, or C, or any combination thereof, such as any of the following: A; B; C; A and B; A and C; B and C; A, B, and C; or multiples of any of A, A, B, C, and C, etc.

[0063] Although the subject matter has been described in language specific to structural features and / or methodological actions, it should be understood that the subject matter defined in the appended claims is not necessarily limited to the specific features or actions described above. Specific embodiments and implementation schemes have been described herein for illustrative purposes, but various modifications may be made without departing from the scope of the embodiments and implementation schemes. The specific features and actions described above are disclosed as example forms for implementing the appended claims. Therefore, the embodiments and implementation schemes are not limited except by the appended claims.

[0064] Any patents, patent applications, and other references mentioned above are incorporated herein by reference. Aspects may be modified, if necessary, to provide further embodiments employing the systems, functions, and concepts of the various references described above. If statements or themes in a document incorporated by reference conflict with statements or themes in the present application, the present application shall take precedence.

Claims

1. A method of operating a memory device, comprising: iterating a set of operations to update one or more accumulation variables corresponding to the target memory portion until a value reaches an accumulation action limit threshold; and In response to the value reaching the cumulative action limit threshold, updating one or more retained variables based on the updated one or more accumulated variables, wherein the one or more retained variables store one or more temperature statistics, the temperature statistics comprising a maximum temperature, a minimum temperature, a median temperature, an average temperature, or a variance of the recorded temperatures, The set of operations includes: in response to detecting a temperature accumulation trigger event, obtaining one or more temperature measurements corresponding to the target memory portion; updating the one or more accumulated variables based on the one or more temperature measurements; and The value is updated for comparison with the cumulative action limit threshold.

2. The method according to claim 1, wherein the one or more retained variables are initially set based on one or more initial temperature measurements relative to the target memory portion; and Wherein the one or more initial temperature measurements are obtained in response to a power-on event or a reset event of the target memory portion.

3. The method according to claim 1, wherein the target memory portion comprises a NAND die; and Wherein the method further comprises: performing a characteristic temperature reading on the NAND die; storing an initial temperature reading resulting from the characteristic temperature reading in the one or more retained variables; and The one or more held variables are repeatedly updated during operation of the NAND die, wherein each update to the one or more held variables is performed by iterating over the set of operations.

4. The method of claim 1 , wherein either or both of (A) the one or more retained variables or (B) the one or more accumulated variables are stored in one or more registers associated with the target memory portion, the registers being allocated for accumulating the temperature statistics. The method according to claim 1 , wherein the cumulative action limit threshold is a user-defined limit.

6. The method of claim 1, wherein the temperature accumulation trigger comprises an indication that an I / O operation has occurred on the target memory portion or an indication that a timer has reached a predetermined value.

7. The method according to claim 1, wherein the target memory portion is a NAND die; wherein the temperature accumulation trigger is an indication of an I / O operation occurring on the NAND die; and Wherein one or more subsequent temperature measurements are obtained from an automated process that records one or more temperature measurements relative to the NAND die as part of the event occurring on the NAND die.

8. The method according to claim 1, wherein the target memory portion is a NAND die; wherein the temperature accumulation trigger is an indication that the timer has reached a predetermined value; and Wherein obtaining the one or more subsequent temperature measurements relative to the NAND die comprises: causing an I / O operation on the NAND die in response to expiration of the timer; and The one or more subsequent temperature measurements are obtained after the I / O operation.

9. The method of claim 1, wherein the one or more maintained variables include: a minimum temperature record that tracks the minimum temperature of the target memory portion; a maximum temperature record that tracks the maximum temperature of the target memory portion; and An average temperature record that tracks the average temperature of the target memory portion.

10. A computer-readable storage medium storing instructions that, when executed by a computing system, cause the computing system to perform operations comprising: iterating a set of operations to update one or more accumulation variables corresponding to the target memory portion until a value reaches an accumulation action limit threshold; and In response to the value reaching the cumulative action limit threshold, updating one or more retained variables based on the updated one or more accumulated variables, wherein the one or more retained variables store one or more temperature statistics, the temperature statistics comprising a maximum temperature, a minimum temperature, a median temperature, an average temperature, or a variance of the recorded temperatures, The set of operations includes: in response to detecting a temperature accumulation trigger event, obtaining one or more temperature measurements corresponding to the target memory portion; updating the one or more accumulated variables based on the one or more temperature measurements; and The value is updated for comparison with the cumulative action limit threshold.

11. The computer-readable storage medium according to claim 10, wherein the target memory portion comprises a NAND die; wherein the one or more retained variables are initially set based on one or more initial temperature measurements relative to the target memory portion; and Wherein said obtaining the one or more initial temperature measurements comprises performing an I / O action on the NAND die that automatically results in the one or more temperature measurements.

12. The computer-readable storage medium of claim 10, wherein either or both of (A) the one or more retained variables or (B) the one or more accumulated variables are stored in one or more registers associated with the target memory portion, the registers being allocated for accumulating the temperature statistics.

13. The computer-readable storage medium of claim 10, wherein the temperature accumulation trigger comprises an indication of an I / O operation occurring on the target memory portion or an indication of a timer reaching a time threshold.

14. The computer-readable storage medium according to claim 10, wherein the target memory portion is a NAND die; wherein the temperature accumulation trigger is an indication of an I / O operation occurring on the NAND die; and Wherein one or more subsequent temperature measurements are obtained from an automated process that records one or more temperature measurements relative to the NAND die as part of the event occurring on the NAND die.

15. The computer-readable storage medium of claim 10, wherein the one or more retained variables include: a minimum temperature record that tracks the minimum temperature of the target memory portion; a maximum temperature record that tracks the maximum temperature of the target memory portion; and An average temperature record that tracks the average temperature of the target memory portion.

16. A memory system comprising: a memory component comprising a target memory portion: and a processing device operably coupled to the memory component, the processing device being configured to: iterating a set of operations to update one or more accumulation variables corresponding to the target memory portion until a value reaches an accumulation action limit threshold; and In response to the value reaching the cumulative action limit threshold, updating one or more retained variables based on the updated one or more accumulated variables, wherein the one or more retained variables store one or more temperature statistics, the temperature statistics comprising a maximum temperature, a minimum temperature, a median temperature, an average temperature, or a variance of the recorded temperatures, The set of operations includes: in response to detecting a temperature accumulation trigger event, obtaining one or more temperature measurements corresponding to the target memory portion; updating the one or more accumulated variables based on the one or more temperature measurements; and The value is updated for comparison with the cumulative action limit threshold.

17. The memory system of claim 16, wherein the target memory portion is a NAND die.

18. The memory system of claim 16, wherein the temperature accumulation trigger comprises an indication that an I / O operation has occurred on the target memory portion or an indication that a timer has reached a predetermined value.

19. The memory system according to claim 18, wherein the target memory portion is a NAND die; wherein the temperature accumulation trigger is an indication of an I / O operation occurring on the NAND die; and Wherein one or more subsequent temperature measurements are obtained from an automated process that records one or more temperature measurements relative to the NAND die as part of the event occurring on the NAND die.

20. The memory system of claim 16, wherein the one or more retained variables include: a minimum temperature record that tracks the minimum temperature of the target memory portion; a maximum temperature record that tracks the maximum temperature of the target memory portion; and An average temperature record that tracks the average temperature of the target memory portion.

Images