Machine Learning for Multi-Memory Systems

By introducing a machine learning engine and buffer memory technology into the multi-memory system, the problem of the interface controller's inability to effectively manage memory commands was solved, resulting in improved device performance, particularly in terms of latency and power efficiency.

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

Patent Information

Application Number
CN202210473008.4
Authority / Receiving Office
CN · China
Patent Type
Patents(China)
Current Assignee / Owner
Priority Date
2022-01-28
Filing Date
2022-04-29
Publication Date
2026-11-17
Estimated Expiration
2042-04-29

AI Technical Summary

Technical Problem

In the prior art, the interface controller of a multi-memory system has difficulty effectively identifying and managing a large number of memory commands, resulting in the inability to improve device performance, such as low latency and low power efficiency.

Method used

A machine learning engine is used to identify patterns in memory commands, and memory operations are optimized through associative mapping and buffer memory techniques, including the use of artificial intelligence neural networks, transformer neural networks, etc., to generate internal commands to improve device performance.

Benefits of technology

By leveraging pattern recognition and buffer memory technologies through machine learning engines, the predictive operation capability of multi-memory systems is improved, latency and power consumption are reduced, and device performance is enhanced.

✦ Generated by Eureka AI based on patent content.

Smart Images

  • Figure CN115312099B_ABST
    Figure CN115312099B_ABST
Patent Text Reader

Abstract

This application relates to machine learning for multi-memory systems. An apparatus may include an interface controller, non-volatile memory, and volatile memory. The interface controller enables the apparatus to receive a first command from a host device. The interface controller enables the apparatus to transmit the first command to a machine learning engine and circuitry configured to store and manage commands for the non-volatile memory and the volatile memory. The interface controller may further enable the apparatus to transmit a second command generated by the machine learning engine to the circuitry. The second command may be based on information determined by the machine learning engine during training.
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 / 587,665, filed January 28, 2022, entitled "Machine Learning for a Multi-Memory System," which claims the benefit of U.S. Provisional Patent Application No. 63 / 185,201, filed May 6, 2021, entitled "Machine Learning for a Multi-Memory System," each of which is assigned to its assignee and is expressly incorporated herein by reference in its entirety. Technical Field

[0003] This technical field relates to machine learning for multi-memory systems. Background Technology

[0004] Memory devices are widely used to store information in various electronic devices such as computers, user devices, wireless communication 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 to support one of two states, often represented by logic 1 or logic 0. In some instances, a single memory cell can support more than two states, any of which can be stored. To access the stored information, a component can read or sense at least one stored state in the memory device. To store information, a component can write states into the memory device or program states.

[0005] Various types of memory devices and memory cells 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), auto-select memory, and chalcogenide memory technology. Memory cells can be volatile or non-volatile. Non-volatile memory, such as FeRAM, can maintain its stored logic state for a long time, even without external power. Volatile memory devices (such as DRAM) may lose their stored state when disconnected from external power. Summary of the Invention

[0006] An apparatus is described. The apparatus may include non-volatile memory; volatile memory configured to operate as a cache memory for the non-volatile memory; and an interface controller coupled to the non-volatile memory and the volatile memory. The interface controller may be configured to cause the apparatus to: receive a first command from a host device; transmit the first command to a machine learning engine and a circuit system configured to store and manage commands for the non-volatile memory and the volatile memory; and transmit a second command generated by the machine learning engine to the circuit system, the second command being at least partially based on information determined by the machine learning engine during a training mode.

[0007] An apparatus is described. The apparatus may include non-volatile memory; volatile memory configured to operate as a cache memory for the non-volatile memory; and an interface controller coupled to the non-volatile memory and the volatile memory. The interface controller may include: a circuit system configured to store and manage commands for the non-volatile memory and the volatile memory; a command decoder configured to receive a first command from a host device and transmit the first command to the circuit system and a machine learning engine; and the machine learning engine configured to generate a second command based at least in part on the information determined by the machine learning engine during a training mode, and configured to transmit the second command to the circuit system.

[0008] An apparatus is described. The apparatus may include: a circuit system configured to store and manage commands for non-volatile memory and volatile memory operating as a cache memory of the non-volatile memory; a command decoder configured to receive a first command from a host device and transmit the first command to the circuit system and a machine learning engine; and the machine learning engine configured to generate a second command based at least in part on information determined by the machine learning engine during a training mode, and configured to transmit the second command to the circuit system. Attached Figure Description

[0009] Figure 1 Examples of machine learning-supporting systems, such as those disclosed herein, are shown.

[0010] Figure 2 An example of a memory subsystem supporting machine learning, based on examples disclosed herein, is shown.

[0011] Figure 3 Examples of machine learning-supporting systems, such as those disclosed herein, are shown.

[0012] Figure 4 An example of a process flow supporting machine learning for multi-memory systems, based on examples disclosed herein, is shown.

[0013] Figure 5 A block diagram of a memory device supporting machine learning for multi-memory systems, based on examples disclosed herein, is shown.

[0014] Figure 6 A flowchart is shown, illustrating one or more methods for supporting machine learning for multi-memory systems, based on examples as disclosed herein. Detailed Implementation

[0015] Devices such as electronic devices may include non-volatile memory (e.g., main memory for storing information in other operations) and volatile memory (e.g., secondary memory), which may operate as a cache for the non-volatile memory. This configuration allows the device to benefit from the advantages of non-volatile memory (e.g., non-volatile and persistent storage, high storage capacity, low power consumption) while maintaining compatibility with the host device through the volatile memory, among other things. To support this type of configuration, the device may include an interface controller representing the interface between the volatile and non-volatile memory and the host device. The interface controller can receive many (e.g., millions, billions) commands from the host device and can manage memory operations of the non-volatile and volatile memory based on these commands. However, due to the number of commands, the interface controller may not be able to recognize the various operating modes associated with the commands and therefore may not be able to perform predictive operations that improve device performance (e.g., reduce latency, reduce power consumption), or may execute a number of commands in a less efficient manner than expected.

[0016] According to the techniques described herein, a device may include an engine (e.g., hardware, software, or a combination of both) that employs machine learning to learn patterns associated with incoming commands (e.g., memory commands) from a host device and generates internal commands (e.g., internal memory commands) based on (e.g., in response to determining) those patterns. In some instances, the machine learning engine may be or may employ artificial intelligence (AI) neural networks, transformer neural networks, long short-term memory (LSTM) neural networks, gated recurrent unit (GRU) neural networks, or other types of learning networks, or combinations thereof. The machine learning engine may group commands into clusters based on (e.g., in response to determining) one or more shared characteristics, making patterns easier to detect, rather than attempting to identify patterns solely based on addresses, which might occur in other different techniques and may be impractical for large command traffic. In this way, the machine learning engine can effectively identify patterns associated with incoming commands and, in doing so, learn information that allows the device to perform predictive operations that improve device performance, as well as other benefits.

[0017] The features of this disclosure were initially described in reference, as in [reference]. Figure 1 and 2 The system and memory subsystem described herein are described in the context of the system and memory subsystem described. Features of this disclosure are described in reference, as per [reference]. Figure 3 The described apparatus and as referenced Figure 4 The process flow described herein is described in the context of the process flow. These and other features of this disclosure are illustrated by reference to, for example, reference 1. Figure 5 and 6 The device diagrams and flowcharts described herein, which relate to machine learning for multi-memory systems, are used to further illustrate and describe the process.

[0018] Figure 1 An example of a machine learning-supporting system 100, as disclosed herein, is illustrated. System 100 may be included in an electronic device such as a computer or telephone. System 100 may include a host device 105 and a memory subsystem 110. Host device 105 may be a processor or system-on-a-chip (SoC) that interfaces with interface controller 115, as well as other components of the electronic device including system 100. Memory subsystem 110 may store electronic information (e.g., digital information, data) for host device 105 and provide access to said electronic information. Memory subsystem 110 may include interface controller 115, volatile memory 120, and non-volatile memory 125. In some instances, interface controller 115, volatile memory 120, and non-volatile memory 125 may be included in the same physical package, such as package 130. However, interface controller 115, volatile memory 120, and non-volatile memory 125 may be disposed on different corresponding dies (e.g., silicon dies).

[0019] The devices in system 100 can be coupled via various wires (e.g., traces, printed circuit board (PCB) wiring, redistribution layer (RDL) wiring) that enable the transmission of information (e.g., commands, addresses, data) between the devices. These wires can form channels, data buses, command buses, address buses, etc.

[0020] The memory subsystem 110 can be configured to provide the benefits of non-volatile memory 125 while maintaining compatibility with host device 105 that supports protocols for different types of memory, such as volatile memory 120, and other instances. For example, non-volatile memory 125 can provide benefits (e.g., relative to volatile memory 120) such as non-volatility, higher capacity, or lower power consumption. However, host device 105 may be incompatible or inefficiently configured with various aspects of non-volatile memory 125. For example, host device 105 may support voltage, access latency, protocols, page sizes, etc., which are incompatible with non-volatile memory 125. To compensate for the incompatibility between host device 105 and non-volatile memory 125, memory subsystem 110 can be configured with volatile memory 120 that is compatible with host device 105 and serves as a cache for non-volatile memory 125. Therefore, host device 105 can use protocols supported by volatile memory 120 while also benefiting from the advantages of non-volatile memory 125.

[0021] In some instances, system 100 may be included in, or coupled to, a computing device, electronic device, mobile computing device, or wireless device. The device may be a portable electronic device. For example, the device may be a computer, laptop computer, tablet computer, smartphone, cellular phone, wearable device, Internet-connected device, etc. In some instances, the device may be configured for bidirectional wireless communication via a base station or access point. In some instances, the device associated with system 100 may be capable of machine-type communication (MTC), machine-to-machine (M2M) communication, or device-to-device (D2D) communication. In some instances, the device associated with system 100 may be referred to as a user equipment (UE), station (STA), mobile terminal, etc.

[0022] Host device 105 can be configured to interface with memory subsystem 110 using a first protocol (e.g., Low Power Double Data Rate (LPDDR)) supported by interface controller 115. Therefore, in some instances, host device 105 can interface directly with interface controller 115 and indirectly with non-volatile memory 125 and volatile memory 120. In alternative instances, host device 105 can interface directly with non-volatile memory 125 and volatile memory 120. Host device 105 can also interface with other components of the electronic device including system 100. Host device 105 can be or can include a SoC, general-purpose processor, digital signal processor (DSP), application-specific integrated circuit (ASIC), field-programmable gate array (FPGA) or other programmable logic device, discrete gate or transistor logic, discrete hardware components, or it can be a combination of these types of components. In some instances, host device 105 can be referred to as a host.

[0023] Interface controller 115 can be configured to interface with volatile memory 120 and non-volatile memory 125 on behalf of host device 105 (e.g., based on or in response to one or more commands or requests issued by host device 105). For example, interface controller 115 can facilitate the retrieval and storage of data in volatile memory 120 and non-volatile memory 125 on behalf of host device 105. Therefore, interface controller 115 can facilitate data transfer between various sub-components, such as data transfer between at least some of host device 105, volatile memory 120, or non-volatile memory 125. Interface controller 115 can interface with host device 105 and volatile memory 120 using a first protocol, and can interface with non-volatile memory 125 using a second protocol supported by non-volatile memory 125.

[0024] Non-volatile memory 125 can be configured to store digital information (e.g., data) of electronic devices including system 100. Therefore, non-volatile memory 125 may include one or more arrays of memory cells and a local memory controller configured to operate the arrays of memory cells. In some instances, the memory cells may be or include FeRAM cells (e.g., non-volatile memory 125 may be FeRAM). Non-volatile memory 125 can be configured to interface with interface controller 115 using a second protocol different from the first protocol used between interface controller 115 and host device 105. In some instances, non-volatile memory 125 may have a longer access operation latency than volatile memory 120. For example, retrieving data from non-volatile memory 125 may take longer than retrieving data from volatile memory 120. Similarly, writing data to non-volatile memory 125 may take longer than writing data to volatile memory 120. In some instances, as described herein, non-volatile memory 125 may have a smaller page size than volatile memory 120.

[0025] Volatile memory 120 can be configured to operate as a cache memory for one or more components, such as non-volatile memory 125. For example, volatile memory 120 can store information (e.g., data) of electronic devices including system 100. Therefore, volatile memory 120 can include one or more arrays of memory cells and a local memory controller configured to operate the arrays of memory cells. In some instances, the memory cells may be or include DRAM cells (e.g., the volatile memory may be DRAM). Non-volatile memory 125 can be configured to interface with interface controller 115 using a first protocol used between interface controller 115 and host device 105.

[0026] In some instances, volatile memory 120 may have shorter access operation latency than non-volatile memory 125. For example, retrieving data from volatile memory 120 may take less time than retrieving data from non-volatile memory 125. Similarly, writing data to volatile memory 120 may take less time than writing data to non-volatile memory 125. In some instances, volatile memory 120 may have a larger page size than non-volatile memory 125. The page size of volatile memory 120 may be 2 kilobytes (2kB), and the page size of non-volatile memory 125 may be 64 bytes (64B) or 128 bytes (128B).

[0027] While non-volatile memory 125 may be a higher-density memory than volatile memory 120, accessing non-volatile memory 125 may take longer than accessing volatile memory 120 (e.g., due to different architectures and protocols, and other reasons). Therefore, operating volatile memory 120 as a cache memory can reduce latency in system 100. As an example, by retrieving data from volatile memory 120 instead of non-volatile memory 125, data access requests from host device 105 can be satisfied relatively quickly. To facilitate the operation of volatile memory 120 as a cache memory, interface controller 115 may include multiple buffers 135. Buffers 135 may be located on the same die as interface controller 115 and may be configured to temporarily store data for transfer between volatile memory 120, non-volatile memory 125, or host device 105 (or any combination thereof) during one or more access operations (e.g., store and retrieve operations).

[0028] An access operation may also be referred to as an access process or access procedure, and may involve one or more sub-operations performed by one or more components of the memory subsystem 110. Examples of access operations may include a storage operation in which data provided by the host device 105 is stored (e.g., written) to volatile memory 120 or non-volatile memory 125 (or both); and a retrieval operation in which data requested by the host device 105 is obtained (e.g., read) from volatile memory 120 or non-volatile memory 125 and returned to the host device 105.

[0029] To store data in memory subsystem 110, host device 105 can initiate a storage operation (or “stored procedure”) by sending a storage command (also referred to as a storage request, write command, or write request) to interface controller 115. The storage command may target a set of non-volatile memory cells in non-volatile memory 125. In some instances, the set of memory cells may also be referred to as a portion of memory. Host device 105 may also provide interface controller 115 with data to be written to the set of non-volatile memory cells. Interface controller 115 may temporarily store the data in buffer 135-a. After storing the data in buffer 135-a, interface controller 115 may transfer the data from buffer 135-a to volatile memory 120 or non-volatile memory 125, or both. In write-through mode, interface controller 115 may transfer data to both volatile memory 120 and non-volatile memory 125. In write-back mode, the interface controller 115 can simply transfer data to volatile memory 120 (wherein data is transferred to non-volatile memory 125 during a later eviction process).

[0030] In any mode, interface controller 115 may identify an appropriate set of one or more volatile memory cells in volatile memory 120 for storing data associated with a store command. To this end, interface controller 115 may implement set-associative mapping, wherein each set of one or more non-volatile memory cells in non-volatile memory 125 may be mapped to multiple sets (e.g., rows) of volatile memory cells in volatile memory 120. For example, interface controller 115 may implement an n-way associative mapping, which allows data from a set of non-volatile memory cells to be stored in one of n sets of volatile memory cells in volatile memory 120. Therefore, interface controller 115 can manage volatile memory 120, which serves as a cache for non-volatile memory 125, by referring to n sets of volatile memory cells associated with a target set of non-volatile memory cells. As used herein, unless otherwise described or referenced, a “set” of objects may refer to one or more of objects. Although described with reference to set-associative mapping, interface controller 115 can manage volatile memory 120 as cache memory by implementing one or more other types of mapping (e.g., direct mapping or associative mapping, and other instances).

[0031] After determining which n sets of volatile memory cells are associated with the target set of non-volatile memory cells, the interface controller 115 can store the data in one or more of the n sets of volatile memory cells. This allows subsequent (e.g., follow-up) retrieval commands from the host device 105 to efficiently satisfy data by retrieving data from the lower latency volatile memory 120 instead of the higher latency non-volatile memory 125. The interface controller 115 can determine which set of the n sets of volatile memory 120 stores the data based on or in response to one or more parameters (such as data validity, age, or modification status) associated with the data stored in the n sets of volatile memory 120. Therefore, storage commands from the host device 105 can be fully (e.g., in write-back mode) or partially (e.g., in write-through mode) satisfied by storing the data in the volatile memory 120. In order to track data stored in volatile memory 120, interface controller 115 can store tag addresses for one or more sets of volatile memory cells (e.g., each set of volatile memory cells), the tag addresses indicating non-volatile memory cells having data stored in a given set of volatile memory cells.

[0032] To retrieve data from memory subsystem 110, host device 105 can initiate a retrieval operation (also referred to as a retrieval process) by sending a retrieval command (also referred to as a retrieval request, read command, or read request) to interface controller 115. The retrieval command can target one or more sets of non-volatile memory cells in non-volatile memory 125. Once a retrieval command is received, interface controller 115 can examine the requested data in volatile memory 120. For example, interface controller 115 can examine the requested data in n sets of volatile memory cells associated with the target set of non-volatile memory cells. If the requested data is stored in one of the n sets of volatile memory cells (e.g., data from the target set of non-volatile memory cells is stored), interface controller 115 can transfer the data from volatile memory 120 to buffer 135-a (e.g., in response to determining whether the requested data is stored in one of the n sets of volatile memory cells, such as...). Figure 4 and 5 (as described in the text), so that it can be transmitted to the host device 105.

[0033] Generally, the term "hit" can be used to refer to a situation where volatile memory 120 stores the data targeted by host device 105. If the requested data is not stored in one or more sets of n volatile memory cells (e.g., the n sets of volatile memory cells store data from a set of non-volatile memory cells other than the target set of non-volatile memory cells), then interface controller 115 can transfer the requested data from non-volatile memory 125 to buffer 135-a (e.g., in response to determining whether the n sets of volatile memory cells do not store the requested data, as referenced). Figure 4 and 5 (as described), so that it can be transmitted to host device 105. Generally, the term "miss" can be used to refer to a situation where the volatile memory 120 does not store the data targeted by host device 105.

[0034] In the event of a data miss, after transferring the requested data to buffer 135-a, interface controller 115 may transfer the requested data from buffer 135-a to volatile memory 120 so that subsequent read requests for the data can be satisfied via volatile memory 120 instead of non-volatile memory 125. For example, interface controller 115 may store the data in one of n sets of volatile memory cells associated with a target set of non-volatile memory cells. However, the n sets of volatile memory cells may already be storing data for other sets of non-volatile memory cells. Therefore, to preserve this other data, interface controller 115 may transfer the other data to buffer 135-b so that the data can be transferred to non-volatile memory 125 for storage. This process can be referred to as "eviction," and the data transferred from volatile memory 120 to buffer 135-b can be referred to as "victim" data.

[0035] In some cases, interface controller 115 may transfer a subset of compromised data from buffer 135-b to non-volatile memory 125. For example, interface controller 115 may transfer one or more subsets of compromised data that have changed since the data was initially stored in non-volatile memory 125. Data that is inconsistent between volatile memory 120 and non-volatile memory 125 (e.g., due to an update in one memory but not the other) may be referred to as “modified” or “dirty” data in some cases. In some instances (e.g., if the interface controller is operating in a mode such as write-back mode), dirty data may be data that exists in volatile memory 120 but not in non-volatile memory 125.

[0036] Therefore, if volatile memory 120 is full, interface controller 115 can execute an eviction procedure to save data from volatile memory 120 to non-volatile memory 125 (e.g., to make room for new data in volatile memory 120). In some instances, interface controller 115 can execute a "filling" procedure, in which data from non-volatile memory 125 is saved to volatile memory 120. Interface controller 115 can execute a filling procedure in the event of a miss (e.g., to fill volatile memory 120 with relevant data). For example, in the event of a read miss if a read command from host device 105 targets data stored in non-volatile memory 125 instead of volatile memory 120, interface controller 115 can retrieve the data requested by the read command (from non-volatile memory 125) and, in addition to returning the data to the host device, also store the data in volatile memory 120 (e.g., so that the data can be quickly retrieved in the future).

[0037] Therefore, depending on whether the request is hit or miss, the memory subsystem 110 can use volatile memory 120 or non-volatile memory 125 to satisfy (or "fulfill") requests from the host device 105 (e.g., read commands, write commands). For example, in the case of a read miss, a read command from the host device 105 can be satisfied via non-volatile memory 125, meaning that the data returned from the host device 105 can originate from non-volatile memory 125. And, in the case of a read hit, a read command from the host device 105 can be satisfied via volatile memory 120, meaning that the data returned from the host device 105 can originate from volatile memory 120. In some instances, the hit-to-miss ratio ("hit-to-miss ratio") may be relatively high (e.g., the hit percentage (or "hit rate") may be about 85%, while the miss percentage (or "miss rate") may be about 15%).

[0038] In some instances, interface controller 115 may use machine learning to preemptively manage volatile memory 120 and non-volatile memory 125, as well as other components and devices. For example, interface controller 115 may be trained during a first mode, such as a training mode, to recognize various patterns associated with commands received during the first mode (e.g., patterns for operating memory subsystem 110). If operating in a second mode, such as a field mode (e.g., a mode in which interface controller 115 operates on user data), interface controller 115 may use information learned during the first mode to predictively perform memory operations based on or in response to commands received from host device 105 (e.g., interface controller 115 may perform one or more memory operations before being instructed or prompted to do so by host device 105).

[0039] System 100 may include any number of non-transitory computer-readable media that support the quality of service information as described herein. For example, host device 105, interface controller 115, volatile memory 120, or non-volatile memory 125 may include or otherwise access one or more non-transitory computer-readable media containing stored instructions (e.g., firmware) for performing the functions attributed herein to host device 105, interface controller 115, volatile memory 120, or non-volatile memory 125. For example, such instructions, if executed by host device 105 (e.g., by a host device controller), by interface controller 115, by volatile memory 120 (e.g., by a local controller), or by non-volatile memory 125 (e.g., by a local controller), may cause host device 105, interface controller 115, volatile memory 120, or non-volatile memory 125 to perform the relevant functions as described herein.

[0040] Figure 2 An example of a memory subsystem 200 supporting machine learning, as disclosed herein, is shown. The memory subsystem 200 may be used as a reference. Figure 1 An example of the described memory subsystem 110. Therefore, the memory subsystem 200 can be compared with, as in the reference... Figure 1 The host device interaction is described. The memory subsystem 200 may include an interface controller 202, volatile memory 204, and non-volatile memory 206, which may be as described in reference... Figure 1 The described interface controller 115, volatile memory 120, and non-volatile memory 125 are examples. Therefore, the interface controller 202 can represent, as referenced... Figure 1 The described host device interfaces with volatile memory 204 and non-volatile memory 206. For example, interface controller 202 can operate volatile memory 204 as a cache for non-volatile memory 206. Operating volatile memory 204 as a cache allows the subsystem to provide the benefits of non-volatile memory 206 (e.g., non-volatile, high-density storage) while maintaining compatibility with host devices that support protocols different from those of non-volatile memory 206.

[0041] exist Figure 2 In this diagram, dashed lines between components represent data flows or data transmission paths, while solid lines between components represent command flows or command transmission paths. In some cases, the memory subsystem 200 is one of several similar or identical subsystems that can be included in an electronic device. In some instances, each subsystem may be referred to as a slice and may be associated with a corresponding channel of the host device.

[0042] Non-volatile memory 206 can be configured to operate as main memory for a host device (e.g., memory for long-term data storage). In some cases, non-volatile memory 206 may include one or more arrays of FeRAM cells. Each FeRAM cell may include a select component and a ferroelectric capacitor and can be accessed by applying an appropriate voltage to one or more access lines such as word lines, board lines, and digital lines. In some instances, a subset of FeRAM cells coupled to an active word line may be sensed, for example, in parallel or simultaneously, without having to sense all FeRAM cells coupled to an active word line. Therefore, the page size of the FeRAM array may be different from (e.g., smaller than) the DRAM page size. In the context of a memory device, a page may refer to memory cells in a row (e.g., a group of memory cells with a common row address), and the page size may refer to the number of memory cells or column addresses in a row, or the number of column addresses accessed during an access operation. Alternatively, the page size may refer to the size of data handled by various interfaces, or the amount of data that a row can store. In some cases, different types of memory devices may have different page sizes. For example, a DRAM page size (e.g., 2kB) can be a superset of a non-volatile memory (e.g., FeRAM) page size (e.g., 64B).

[0043] The smaller page size of FeRAM arrays can offer various efficiency benefits because a single FeRAM cell may require more power to read or write than a single DRAM cell. For example, the smaller page size of a FeRAM array can facilitate efficient energy use because fewer FeRAM cells can be activated if the relevant changes in information are small. In some instances, depending on the nature of the data and commands utilizing FeRAM operations, the page size of the FeRAM cell array can, for example, change dynamically (e.g., during the operation of the FeRAM cell array).

[0044] While a single FeRAM cell may require more power to read or write than a single DRAM cell, FeRAM cells can maintain their stored logic state for extended periods without an external power supply because the ferroelectric material within the FeRAM cell can remain non-zero polarized in the absence of an electric field. Therefore, including an FeRAM array in the non-volatile memory 206 can provide power and efficiency benefits relative to volatile memory cells (e.g., DRAM cells in the volatile memory 204) because it reduces or eliminates constraints on performing refresh operations.

[0045] Volatile memory 204 can be configured as a cache memory for non-volatile memory 206. In some cases, volatile memory 204 may include one or more arrays of DRAM cells. Each DRAM cell may include a capacitor comprising a dielectric material to store charge representing a programmable state. The memory cells of volatile memory 204 may be logically grouped or arranged into one or more memory groups (as referred to herein as “groups”). For example, volatile memory 204 may include sixteen groups. The memory cells of a group may be arranged in a grid or an array of intersecting columns and rows, and each memory cell may be accessed or refreshed by applying appropriate voltages to the digital lines (e.g., column lines) and word lines (e.g., row lines) for that memory cell. A row of a group may be referred to as a page, and the page size may be referred to as the number of columns or memory cells in the row (and therefore, the amount of data that the row can store). As mentioned, the page size of volatile memory 204 may be different from (e.g., larger than) the page size of non-volatile memory 206.

[0046] Interface controller 202 may include various circuitry for interfacing (e.g., communicating) with other devices, such as host devices, volatile memory 204, and non-volatile memory 206. For example, interface controller 202 may include a data (DA) bus interface 208, a command and address (C / A) bus interface 210, a data bus interface 212, a C / A bus interface 214, a data bus interface 216, and a C / A bus interface 264. The data bus interfaces may support the transmission of information using one or more communication protocols. For example, data bus interface 208, C / A bus interface 210, data bus interface 216, and C / A bus interface 264 may support information transmitted using a first protocol (e.g., LPDDR signaling), while data bus interface 212 and C / A bus interface 214 may support information transmitted using a second protocol. Therefore, the various bus interfaces coupled to interface controller 202 may support different data volumes or data rates.

[0047] Data bus interface 208 can be coupled to data bus 260, transaction bus 222, and buffer circuitry 224. Data bus interface 208 can be configured to send and receive data via data bus 260 and to send and receive control information (e.g., acknowledgment / negative acknowledgment) or metadata via transaction bus 222. Data bus interface 208 can also be configured to transfer data between data bus 260 and buffer circuitry 224. Data bus 260 and transaction bus 222 can be coupled to interface controller 202 and host device, establishing a conductive path between interface controller 202 and host device. In some instances, the pin of transaction bus 222 may be referred to as a Data Mask Inversion (DMI) pin. Although shown as having one data bus 260 and one transaction bus 222, any number of data buses 260 and any number of transaction buses 222 may be coupled to one or more data bus interfaces 208.

[0048] C / A bus interface 210 can be coupled to C / A bus 226 and decoder 228. C / A bus interface 210 can be configured to send and receive commands and addresses via C / A bus 226. Commands and addresses received via C / A bus 226 can be associated with data received or sent via data bus 260. C / A bus interface 210 can also be configured to send commands and addresses to decoder 228, enabling decoder 228 to decode commands and relay the decoded commands and associated addresses to command circuitry system 230.

[0049] Data bus interface 212 can be coupled to data bus 232 and memory interface circuitry 234. Data bus interface 212 can be configured to send and receive data via data bus 232, which can be coupled to non-volatile memory 206. Data bus interface 212 can also be configured to transfer data between data bus 232 and memory interface circuitry 234. C / A bus interface 214 can be coupled to C / A bus 236 and memory interface circuitry 234. C / A bus interface 214 can be configured to receive commands and addresses from memory interface circuitry 234 and relay commands and addresses to non-volatile memory 206 via C / A bus 236 (e.g., to a local controller of non-volatile memory 206). Commands and addresses sent via C / A bus 236 can be associated with data received or sent via data bus 232. The data bus 232 and the C / A bus 236 can be coupled to the interface controller 202 and the non-volatile memory 206, thereby establishing a conductive path between the interface controller 202 and the non-volatile memory 206.

[0050] Data bus interface 216 can be coupled to data bus 238 (e.g., data bus 238-a, data bus 238-b) and memory interface circuitry 240. Data bus interface 216 can be configured to send and receive data via data bus 238, which can be coupled to volatile memory 204. Data bus interface 216 can also be configured to transfer data between data bus 238 and memory interface circuitry 240. C / A bus interface 264 can be coupled to C / A bus 242 and memory interface circuitry 240. C / A bus interface 264 can be configured to receive commands and addresses from memory interface circuitry 240 and relay commands and addresses to volatile memory 204 (e.g., to a local controller of volatile memory 204) via C / A bus 242. Commands and addresses sent via C / A bus 242 can be associated with data received or sent via data bus 238. The data bus 238 and the C / A bus 242 can be coupled to the interface controller 202 and the volatile memory 204, thereby establishing a conductive path between the interface controller 202 and the volatile memory 204.

[0051] In addition to the bus and bus interface for communicating with the coupled device, the interface controller 202 may also include circuitry for operating the non-volatile memory 206 as main memory and the volatile memory 204 as cache memory. For example, the interface controller 202 may include a command circuitry 230, a buffer circuitry 224, a cache memory management circuitry 244, one or more engines 246, and one or more schedulers 248.

[0052] Command circuitry system 230 may be coupled to buffer circuitry system 224, decoder 228, cache memory management circuitry system 244, scheduler 248, and other components. Command circuitry system 230 may be configured to receive command and address information from decoder 228 and store the command and address information in queue 250. Command circuitry system 230 may include logic 262 that processes command information (e.g., from the host device) and stored information from other components (e.g., cache memory management circuitry system 244, buffer circuitry system 224), and uses this information to generate one or more commands for scheduler 248. Command circuitry system 230 may also be configured to transmit address information (e.g., address bits) to cache memory management circuitry system 244. In some instances, logic 262 may be circuitry configured to operate as a finite state machine (FSM).

[0053] Buffer circuitry system 224 may be coupled to data bus interface 208, command circuitry system 230, memory interface circuitry system 234, and memory interface circuitry system 240. Buffer circuitry system 224 may include a collection of one or more buffer circuits for at least some groups (if not every group) of volatile memory 204. Buffer circuitry system 224 may also include components for accessing the buffer circuits (e.g., a memory controller). In one example, volatile memory 204 may include sixteen groups and buffer circuitry system 224 may include sixteen collections of buffer circuits. Each collection of buffer circuits may be configured to store data from a corresponding group of volatile memory 204 or data for a corresponding group of said volatile memory (or both). As an example, buffer circuitry (BK0) set for group 0 may be configured to store data from the first group of volatile memory 204 or data for the first group (or both), and buffer circuitry (BK15) for group 15 may be configured to store data from the sixteenth group of volatile memory 204 or data for the sixteenth group (or both).

[0054] Each set of buffer circuits in buffer circuit system 224 may include a pair of buffers. The pair of buffers may include: one buffer (e.g., an Open Page Data (OPD) buffer) configured to store data targeted by an access command (e.g., a write command or read command) from a host device; and another buffer (e.g., a Victim Page Data (VPD) buffer) configured to store data for use in an eviction process triggered by an access command. For example, the set of buffer circuits for BK0 may include buffers 218 and 220, which may be instances of buffers 135-a and 135-b, respectively. Buffer 218 may be configured to store BK0 data targeted by an access command from a host device. Buffer 220 may be configured to store data transferred from BK0 as part of a eviction process triggered by an access command. Each buffer in the set of buffer circuits may be configured to have a size (e.g., storage capacity) corresponding to the page size of volatile memory 204. For example, if the page size of volatile memory 204 is 2kB, then the size of each buffer may be 2kB. Therefore, in some instances, the size of the buffer can be equivalent to the page size of the volatile memory 204.

[0055] The cache memory management circuitry system 244 may be coupled to the command circuitry system 230, the engine 246, and the scheduler 248, as well as other components. The cache memory management circuitry system 244 may include a set of cache memory management circuits for one or more groups (e.g., each group) of volatile memory. As an example, the cache memory management circuitry system 244 may include sixteen sets of cache memory management circuits for BK0 through BK15. Each set of cache memory management circuits may include two memory arrays that can be configured to store storage information of volatile memory 204. As an example, the cache memory management circuitry set for BK0 may include memory array 252 (e.g., a cache memory DRAM (CDRAM) tag array (CDT-TA)) and memory array 254 (e.g., a CDRAM active (CDT-V) array) that can be configured to store storage information of BK0. In some instances, the memory array may also be referred to as an array or a buffer. In some cases, the memory array may be or include volatile memory cells, such as static RAM (SRAM) cells.

[0056] Storage information (or “metadata”) may include content information, validity information, and / or dirty information (or any combination thereof) associated with volatile memory 204, as well as other instances. Content information (which may also be referred to as tag information or address information) indicates which data is stored in a set of volatile memory cells. For example, the content information (e.g., tag address) of a row in volatile memory 204 may indicate which set of one or more non-volatile memory cells currently contains the data stored in the row. As mentioned, validity information may indicate whether the data stored in the set of volatile memory cells is actual data (e.g., data with an expected order or form) or placeholder data (e.g., random or dummy data without an expected or important order). Furthermore, dirty information may indicate whether the data stored in the set of one or more volatile memory cells of volatile memory 204 differs from the corresponding data stored in the set of one or more non-volatile memory cells of non-volatile memory 206. For example, dirty information can indicate whether data stored in the set of volatile memory cells has been updated relative to data stored in non-volatile memory 206.

[0057] Memory array 252 may include memory cells storing storage information (e.g., tag information, validity information, dirty information) of a related group (e.g., BK0) of volatile memory 204. The storage information may be stored on a row-by-row basis (e.g., there may be corresponding storage information for each row of an associated non-volatile memory group). Interface controller 202 can examine requested data in volatile memory 204 by referring to the storage information in memory array 252. For example, interface controller 202 may receive a retrieval command from a host device for data in a set of non-volatile memory cells in non-volatile memory 206. Interface controller 202 may refer to the storage information in memory array 252 using a set of one or more address bits (e.g., a set of row address bits) targeted by the access request. For example, using set-associative mapping, interface controller 202 can refer to content information in memory array 252 to determine which set of volatile memory cells (if any) stores the requested data.

[0058] In addition to storing content information for the volatile memory cells, memory array 252 may also store validity information indicating whether data in the set of volatile memory cells is actual data (also called valid data) or random data (also called invalid data). For example, volatile memory cells in volatile memory 204 may initially store random data and continue to do so until data is written to the volatile memory cells from a host device or non-volatile memory 206. To track which data is valid, memory array 252 may be configured to set a bit for each set (e.g., row) of volatile memory cells if actual data is stored there. This bit may be called a validity bit or validity flag. Like content information, validity information stored in memory array 252 may be stored on a per-row basis. Thus, in some instances, each validity bit may indicate the validity of data stored in the associated row.

[0059] In some instances, memory array 252 may store dirty information indicating whether a set of volatile memory cells (e.g., rows) stores any dirty data. Similar to validity information, the dirty information stored in memory array 252 may be stored on a per-row basis.

[0060] Memory array 254 may be similar to memory array 252 and may also include memory cells that store storage information for groups (e.g., BK0) of volatile memories 204 associated with memory array 252. For example, memory array 254 may store validity information and dirt information for groups of volatile memories 204. However, the storage information stored in memory array 254 may be stored on a sub-block basis rather than on a row basis. For example, validity information stored in memory cells of memory array 254 may indicate the validity of data for a subset of volatile memory cells in a row of volatile memories 204.

[0061] As an example, validity information in memory array 254 can indicate the validity of each subset (e.g., 32B or 64B) of data stored in row BK0 of volatile memory 204. Similarly, dirty information stored in memory cells of memory array 254 can indicate which subsets of volatile memory cells in rows of volatile memory 204 store dirty data. For example, dirty information in memory array 254 can indicate the dirty state of each subset (e.g., 32B or 64B) of data stored in row BK0 of volatile memory 204. Storing storage information (e.g., tag information, validity information) in memory array 252 based on each row allows interface controller 202 to determine whether there is a hit or a miss in volatile memory 204. The storage of information (e.g., validity information, dirty information) based on sub-blocks in memory array 254 allows interface controller 202 to determine which one or more subsets of data to return to the host device (e.g., during a retrieval process) and which one or more subsets of data to retain in non-volatile memory 206 (e.g., during an eviction process).

[0062] Each cache management circuitry may also include a corresponding pair of registers coupled to command circuitry 230, engine 246, memory interface circuitry 234, memory interface circuitry 240, and the memory array for the cache management circuitry, as well as other components. For example, the cache management circuitry may include a first register (e.g., register 256, which may be an Open Page Tag (OPT) register) configured to receive storage information (e.g., tag information, validity information, or dirty information, other information, or any combination of bits) from memory array 252 or scheduler 248-b, or both. The cache management circuitry may also include a second register (e.g., register 258, which may be a Victim Page Tag (VPT) register) configured to receive storage information (e.g., validity information and / or dirty information, or both) from memory array 254 and scheduler 248-a, or both. Information in registers 256 and 258 may be transmitted to command circuitry 230 and engine 246 to enable decisions to be made by these components. For example, the command circuitry 230 can issue a command to read non-volatile memory 206 or volatile memory 204 based on or in response to stored information in register 256 or register 258 or both.

[0063] Engine 246-a can be coupled to registers 256 and 258 and scheduler 248. Engine 246-a can be configured to receive storage information from various components and issue commands to scheduler 248 based on or in response to the storage information. For example, if interface controller 202 is in a first mode such as write-through mode, engine 246-a can issue a command to scheduler 248-b, and in response, scheduler 248-b initiates or facilitates the transfer of data from buffer 218 to volatile memory 204 and non-volatile memory 206. Alternatively, if interface controller 202 is in a second mode such as write-back mode, engine 246-a can issue a command to scheduler 248-b, and in response, scheduler 248-b can initiate or facilitate the transfer of data from buffer 218 to volatile memory 204. In the case of a write-back operation, the data stored in volatile memory 204 can eventually be transferred to non-volatile memory 206 during a subsequent (e.g., subsequent) eviction process.

[0064] Engine 246-b can be coupled to register 258 and scheduler 248-a. Engine 246-b can be configured to receive stored information from register 258 and issue commands to scheduler 248-a based on or in response to the stored information. For example, engine 246-b can issue commands to scheduler 248-a to initiate or facilitate the transfer of dirty data from buffer 220 to non-volatile memory 206 (e.g., as part of a retrieval process). If buffer 220 holds a set of data transferred from volatile memory 204 (e.g., victim data), engine 246-b can indicate which one or more subsets (e.g., which 64B) of the set of data in buffer 220 should be transferred to non-volatile memory 206.

[0065] Scheduler 248-a can be coupled to various components of interface controller 202 and can facilitate access to non-volatile memory 206 by issuing commands to memory interface circuitry 234. Commands issued by scheduler 248-a can be based on or in response to commands from command circuitry 230, engine 246-a, engine 246-b, or a combination of these components. Similarly, scheduler 248-b can be coupled to various components of interface controller 202 and can facilitate access to volatile memory 204 by issuing commands to memory interface circuitry 240. Commands issued by scheduler 248-b can be based on or in response to commands from command circuitry 230 or engine 246-a, or both.

[0066] The memory interface circuitry 234 can communicate with the non-volatile memory 206 via one or more of the data bus interface 212 and the C / A bus interface 214. For example, the memory interface circuitry 234 can prompt the C / A bus interface 214 to relay commands issued by the memory interface circuitry 234 via the C / A bus 236 to the local controller in the non-volatile memory 206. Furthermore, the memory interface circuitry 234 can send data to or receive data from the non-volatile memory 206 via the data bus 232. In some instances, commands issued by the memory interface circuitry 234 may be supported by the non-volatile memory 206 but not by the volatile memory 204 (e.g., commands issued by the memory interface circuitry 234 may differ from commands issued by the memory interface circuitry 240).

[0067] The memory interface circuitry 240 can communicate with the volatile memory 204 via one or more of the data bus interface 216 and the C / A bus interface 264. For example, the memory interface circuitry 240 can prompt the C / A bus interface 264 to relay commands issued by the memory interface circuitry 240 via the C / A bus 242 to the local controller of the volatile memory 204. Furthermore, the memory interface circuitry 240 can send data to or receive data from the volatile memory 204 via one or more data buses 238. In some instances, commands issued by the memory interface circuitry 240 can be supported via the volatile memory 204 instead of the non-volatile memory 206 (e.g., commands issued by the memory interface circuitry 240 may differ from commands issued by the memory interface circuitry 234).

[0068] In summary, the components of interface controller 202 can operate non-volatile memory 206 as main memory and volatile memory 204 as cache memory. This operation can be prompted by one or more access commands (e.g., read / retrieve command / request and write / store command / request) received from the host device.

[0069] In some instances, interface controller 202 may receive a storage command from the host device. The storage command may be received via C / A bus 226 and transmitted to command circuitry 230 via one or more of C / A bus interface 210 and decoder 228. The storage command may include or be accompanied by address bits targeting the memory address of non-volatile memory 206. Data to be stored may be received via data bus 260 and transmitted to buffer 218 via data bus interface 208. In write-through mode, interface controller 202 may transmit data to both non-volatile memory 206 and volatile memory 204. In write-back mode, in some instances, interface controller 202 may transmit data only to volatile memory 204.

[0070] In either mode, the interface controller 202 may first check whether the volatile memory 204 has space available for storing data in its memory cells. To this end, the command circuitry 230 may refer to the memory array 252 (e.g., using a set of memory address bits) to determine whether one or more of the n sets (e.g., rows) of volatile memory cells associated with a memory address are empty (e.g., storing random or invalid data) or whether one or more of the n sets (e.g., rows) of volatile memory cells associated with a memory address are full (e.g., storing valid data). For example, the command circuitry 230 may determine whether one or more of the n sets (e.g., rows) of volatile memory cells are available (or unavailable) based on or in response to determining tag information and validity information stored in the memory array 252. In some cases, the set of volatile memory cells in the volatile memory 204 may be referred to as a line, cache line, or row.

[0071] If one of the n associated sets of volatile memory cells is available for storing information, the interface controller 202 can transfer data from buffer 218 to volatile memory 204 for storage in that set of volatile memory cells. However, if no associated set of volatile memory cells is empty, the interface controller 202 can initiate an eviction process to free up space in volatile memory 204 for data. The eviction process may involve transferring compromised data from one of the n associated sets of volatile memory cells to buffer 220. Dirty information of the compromised data can be transferred from memory array 254 to register 258 to identify a dirty subset of the compromised data. After the compromised data is stored in buffer 220, new data can be transferred from buffer 218 to volatile memory 204, and compromised data can be transferred from buffer 220 to non-volatile memory 206. In some cases, a dirty subset of old data can be transferred to non-volatile memory 206, and a clean subset (e.g., an unmodified subset) can be discarded. A dirty subset can be identified by engine 246-b based on or in response to dirty information transferred from memory array 254 to register 258 during the eviction process.

[0072] In another example, interface controller 202 may receive commands, such as retrieval commands, from a host device. Retrieval commands can be received via C / A bus 226 and transmitted to command circuitry 230 via one or more of C / A bus interface 210 and decoder 228. Retrieval commands may include address bits targeting a memory address of non-volatile memory 206. Before attempting to access the target memory address of non-volatile memory 206, interface controller 202 may check to see if volatile memory 204 stores data. To this end, command circuitry 230 may refer to memory array 252 (e.g., using a set of memory address bits) to determine whether one or more of the n sets (e.g., rows) of volatile memory cells associated with the memory address store the requested data (e.g., whether one or more of the n sets of volatile memory cells associated with the memory address store the requested data or alternatively, not store the requested data). If the requested data is stored in volatile memory 204, the interface controller 202 can transfer the requested data to buffer 218 for transmission to the host device via data bus 260.

[0073] If the requested data is not stored in volatile memory 204 (e.g., the requested data may be stored in non-volatile memory 206 or other locations), interface controller 202 may retrieve the data from non-volatile memory 206 and transfer the data to buffer 218 for transmission to the host device via data bus 260. Alternatively, interface controller 202 may transfer the requested data from buffer 218 to volatile memory 204, allowing for access to the data with lower latency during subsequent retrieval operations. However, before transferring the requested data, interface controller 202 may first determine whether one or more of the n associated sets of volatile memory cells are available to store the requested data (e.g., whether one or more of the n associated sets of volatile memory cells are empty or full). Interface controller 202 may determine the availability of the n associated sets of volatile memory cells by communicating with the associated cache memory management circuitry. If the associated set of volatile memory cells is available, the interface controller 202 may transfer the data in buffer 218 to volatile memory 204 without performing an eviction process. Otherwise, the interface controller 202 may transfer the data from buffer 218 to volatile memory 204 after performing an eviction process.

[0074] The memory subsystem 200 can be implemented in one or more configurations, including single-chip and multi-chip versions. The multi-chip version may include one or more components of the memory subsystem 200, including interface controller 202, volatile memory 204, and non-volatile memory 206 (and other components or combinations thereof), on a separate chip from the chip that includes one or more other components of the memory subsystem 200. For example, in a multi-chip version, the corresponding individual chip may include each of interface controller 202, volatile memory 204, and non-volatile memory 206. Conversely, the single-chip version may include interface controller 202, volatile memory 204, and non-volatile memory 206 on a single chip.

[0075] In some instances, interface controller 202 may include a machine learning engine that generates commands for memory subsystem 200 based on or in response to commands from a host device and information determined from machine learning. The machine learning engine may communicate the generated commands to command circuitry 230, which may store and manage the commands in the same manner as commands received from the host device. The machine learning engine may be centralized relative to volatile memory 204 and non-volatile memory 206, meaning that the machine learning engine can use machine learning to detect patterns (e.g., operating patterns) associated with commands for volatile memory 204 and patterns associated with commands for non-volatile memory 206. In some instances, the machine learning engine may use different neural networks, algorithms, learning mechanisms, or models for volatile memory 204 and non-volatile memory 206. By preemptively (e.g., predictively, anticipatingly) generating commands based on or in response to machine learning, interface controller 202 may improve the performance of memory subsystem 200 (e.g., reduce latency, reduce power consumption).

[0076] Figure 3 An example of a machine learning-supporting system 300, as disclosed herein, is shown. System 300 may include a host device 305 and a memory subsystem 310, and may be as described in reference [reference needed]. Figure 1 An example of the described system 100. The memory subsystem 310 may include an interface controller 315, volatile memory 320, and non-volatile memory 325, which may be coupled to each other via one or more transmission lines, buses, or both. The interface controller 315 may be an example of interface controller 202 and may include a decoder 330, a machine learning (ML) engine 335, a transaction command queue (TCQ) circuitry system 340, and a pattern controller 345. The interface controller 315 may use machine learning to improve the performance of the memory subsystem 310.

[0077] Decoder 330 can be configured to (e.g., via C / A bus 350) receive commands from host device 305 and decode the received commands. Decoder 330 can also be configured to transmit the decoded commands to ML engine 335 and TCQ circuitry 340, each of which can be coupled to decoder 330. In some instances, decoder 330 can be configured to transmit decoded commands to ML engine 335 and TCQ circuitry 340 in parallel (e.g., decoder 330 can transmit commands to ML engine 335 and TCQ circuitry 340 simultaneously).

[0078] The TCQ circuitry system 340 may be an instance of the command circuitry system 230 and may be configured to store commands for the memory subsystem 310 and manage the delivery of commands to the appropriate components of the memory subsystem 310. In other words, the TCQ circuitry system 340 may be configured to temporarily buffer commands and distribute (e.g., transmit, send) commands to other components of the memory subsystem 310, such as schedulers of the volatile memory 320 and non-volatile memory 325 (e.g., schedulers similar to schedulers 248-a and 248-b). The TCQ circuitry system 340 may include an array 355 (also referred to as a buffer, queue, or storage structure) and logic 360. The array 355 may store commands received from the decoder 330 (and commands received from the ML engine 335) and control information corresponding to these commands, such as address information (e.g., group information, row information, column information) and QoS information. Logic 360 can be configured to determine command hits and misses, as well as other information, so that TCQ circuitry 340 can transmit commands and other control information from array 355 to the appropriate scheduler.

[0079] The ML engine 335 can perform machine learning and generate commands based on (e.g., according to or in response to) information determined to be part of machine learning. Therefore, the ML engine 335 can support a first mode such as a training mode and a second mode such as a live mode, in which the ML engine performs machine learning and in the live mode, the ML engine uses information from the training mode to generate commands. In some instances, the ML engine 335 can support continuous learning, meaning the ML engine can be configured to use information (e.g., information based on commands associated with user data) to generate predictive commands during a duration of operation in the live mode. The ML engine 335 can be or includes software, hardware, or a combination thereof configured to perform machine learning.

[0080] In training mode, ML engine 335 can receive command sequences that allow the ML engine to detect various patterns associated with the command sequences (e.g., operating patterns of memory subsystem 310). ML engine 335 can use the patterns and information learned during training mode to construct one or more models, which it can use to process commands during field mode. Instead of detecting patterns solely based on memory addresses (which can be inefficient, impractical, or otherwise disadvantageous for a large number of commands), ML engine 335 can group received commands (e.g., logically) based on (e.g., determined as a condition or in response to determination) one or more shared characteristics, and then detect patterns based on (e.g., by reference) the grouped commands. For example, ML engine 335 can create address clusters based on (e.g., according to or in response to determination) characteristics and look up pattern information within or based on the address clusters (as opposed to detecting pattern information based on all addresses). Shared characteristics can also be referred to as memory reference characteristics.

[0081] In some instances, the ML engine 335 may group commands based on (e.g., determined as a condition or in response to a determination) the read bandwidth associated with the command. Read bandwidth may refer to the amount of data read from volatile memory 320, non-volatile memory 325, or both during a predetermined time period. In some instances, the ML engine 335 may group commands based on (e.g., determined as a condition or in response to a determination) the write bandwidth associated with the command. Write bandwidth may refer to the amount of data written to volatile memory 320, non-volatile memory 325, or both during a predetermined time period.

[0082] In some instances, the ML engine 335 can group commands based on (e.g., determined as a condition or in response to a determination) the read distance associated with the command. Read distance can refer to the amount of time between consecutive read operations on a set of data or a memory address. In some instances, the ML engine 335 can group commands based on (e.g., determined as a condition or in response to a determination) the write distance associated with the command. Write distance can refer to the amount of time between consecutive write operations on a set of data or a memory address.

[0083] In some instances, the ML engine may group commands based on (e.g., as a condition or in response to a determination) the read turnaround time associated with the command. Read turnaround time can refer to the amount of time between changing the direction of the data bus (e.g., a bidirectional data bus) from a write direction (where data is conveyed from interface controller 315) to a read direction (where data is conveyed to interface controller 315). In some instances, the ML engine may group commands based on (e.g., as a condition or in response to a determination) the write turnaround time associated with the command. Write turnaround time can refer to the amount of time between changing the direction of the data bus (e.g., a bidirectional data bus) from a read direction to a write direction.

[0084] In some instances, the ML engine may group commands based on (e.g., as determined or in response to determination) a reuse distance associated with the command. Reuse distance may refer to the amount of time between the use and reuse of the same data location (e.g., a memory address). In some instances, the ML engine may group commands based on (e.g., as determined or in response to determination) an eviction distance or eviction frequency associated with the command. Eviction distance may refer to the amount of time a set of data is stored in volatile memory 320 (e.g., at a specific address) before undergoing an eviction procedure. Alternatively, eviction distance may refer to the amount of time between evictions of memory addresses in volatile memory 320. Eviction frequency may refer to the number of times a set of data or a memory address undergoes an eviction procedure within a predetermined amount of time. In some instances, eviction distance or eviction frequency may be based on (e.g., corresponding to or in response to determination) a set and / or manner associated with one or more commands. In some instances, the ML engine 335 may predict addresses and victim pages based on or in response to determined address patterns. In some instances, ML Engine 335 can group commands based on page open and close timings associated with them. Page open and close timings can refer to the amount of time an open page remains open (e.g., the amount of time between opening and closing a page).

[0085] Although described with reference to various features, ML Engine 335 can group commands based on other features not described in this article.

[0086] In field mode, ML engine 335 can use information learned during training mode (or information learned earlier in field mode, or a combination thereof) to generate various commands for memory subsystem 310. For example, ML engine 335 can use information from training mode and / or one or more models to determine that one or more commands from host device 305 are associated with a specific operation. Therefore, ML engine 335 can generate one or more commands for TCQ circuit system 340 to predictively facilitate or implement operations (e.g., before being implicitly or explicitly prompted to do so by one or more additional commands from host device 305). Thus, ML engine 335 can use cluster-based pattern information to determine that one or more commands are associated with a specific operation or procedure. In some instances, ML engine 335 can group commands in field mode based on or in response to determining one or more shared characteristics, and use the grouped commands (or "clusters") to predict one or more operations of memory subsystem 310.

[0087] In some instances, the ML engine 335 can determine that one or more commands from the host device 305 are associated with a given operation such as a pre-fetch operation, in which data is retrieved from volatile memory 320 or non-volatile memory 325 before the host device 305 requests data. Therefore, the ML engine 335 can generate one or more commands associated with the pre-fetch operation (e.g., for implementing the pre-fetch operation) and can pass one or more commands to the TCQ circuitry system 340 for processing (e.g., storage and distribution). In some instances, the ML engine 335 can determine that one or more commands from the host device 305 are associated with an eviction operation, in which data from volatile memory 320 is stored in non-volatile memory 325. Therefore, the ML engine 335 can generate one or more commands associated with the eviction operation (e.g., for implementing the eviction operation) and can pass one or more commands to the TCQ circuitry system 340 for processing.

[0088] In some instances, the ML engine 335 can determine one or more commands from the host device 305 that are associated with opening (e.g., activating) or closing (e.g., deactivating) a page in non-volatile memory 325 or volatile memory 320. Therefore, the ML engine 335 can generate one or more commands associated with (e.g., for implementing) a page open or page close operation, and can transmit one or more commands to the TCQ circuitry 340 for processing.

[0089] In some instances, the ML engine 335 can determine that one or more commands from the host device 305 are associated with a cache hit or cache miss. Therefore, the ML engine 335 can generate one or more commands associated with the operations associated with the cache hit or cache miss (e.g., for implementing these operations), and can transmit one or more commands to the TCQ circuitry 340 for processing. In some instances, the ML engine 335 can determine that one or more commands from the host device 305 are associated with a write-back operation or a write-through operation. Therefore, the ML engine 335 can generate one or more commands associated with the write-back or write-through procedure (e.g., for implementing the write-back or write-through procedure), and can transmit one or more commands to the TCQ circuitry 340 for processing.

[0090] In some instances, the ML engine 335 can determine that one or more commands from the host device 305 are associated with a power mode of the volatile memory 320 or the non-volatile memory 325. For example, the ML engine 335 can determine that one or more commands from the host device 305 are associated with a low-power mode of the volatile memory 320, the non-volatile memory 325, or both. Therefore, the ML engine 335 can generate a power mode command indicating a low-power mode and transmit that power mode command to the mode controller 345. The mode controller 345 may consist of, or include, a first mode controller configured to control the power mode of the non-volatile memory 325 and a second mode controller configured to control the power mode of the volatile memory 320. Therefore, the ML engine 335 can use machine learning to predict power mode transitions, which can allow the memory subsystem 310 to save power.

[0091] Although this article describes various operations, the ML Engine 335 can generate commands for other types of operations not explicitly detailed in this article.

[0092] Therefore, by leveraging machine learning, the interface controller 315 can generate commands in anticipation of expected operations, which can reduce system wait time and power consumption.

[0093] Figure 4 An example of a process flow 400 supporting machine learning for multi-memory systems, as disclosed herein, is shown. Process flow 400 can be derived from, as referenced... Figure 1 The memory subsystem 110 or interface controller 115 described, as referenced Figure 2 The memory subsystem 200 or interface controller 202 described herein, or as referenced Figure 3The described memory subsystem 310 or interface controller 315 is used to implement process flow 400. However, other types of devices or components can implement process flow 400. Process flow 400 can illustrate the operation of a device that uses machine learning to generate commands.

[0094] For ease of reference, process flow 400 is described with reference to an apparatus. For example, aspects of process flow 400 may be implemented by means including volatile memory and non-volatile memory. Alternatively, aspects of process flow 400 may be implemented as instructions stored in memory (e.g., firmware stored in volatile memory 120 or non-volatile memory 125 or both). For example, if the instructions are executed by a controller, the controller may perform the operation of process flow 400.

[0095] At 405, machine learning can be performed. For example, ML engine 335 can perform machine learning in a first mode, such as a training mode. In training mode, ML engine 335 can receive a sequence of commands from host device 305 and detect operational patterns associated with the commands by grouping the commands based on one or more shared characteristics (e.g., conditional on one or more shared characteristics, based on one or more shared characteristics). The command sequence can be used to train ML engine 335 and may not be associated with user data. In some instances, ML engine 335 can build one or more models or algorithms based on (e.g., in response to) training. At 410, a field mode can be entered. For example, ML engine 335 can enter a field mode. During field mode, commands associated with user data can be received from host device 305, and ML engine 335 can process the commands based on (e.g., in response to) machine learning information determined during training mode.

[0096] At 415, a first command can be received. For example, decoder 330 can receive the first command (possibly among / with other commands) from host device 305. At 420, the first command (possibly among / with other commands) can be transmitted to TCQ circuitry 340 and ML engine 335. For example, decoder 330 can transmit the first command to TCQ circuitry 340 and ML engine 335. In some instances, the first command can be transmitted to TCQ circuitry 340 and ML engine 335 in parallel (e.g., simultaneously, concurrently, at partially overlapping times). In some instances, decoder 330 can decode the first command before transmitting it to TCQ circuitry 340 and ML engine 335.

[0097] At 425, a second command can be generated. For example, ML engine 335 can generate the second command based on (e.g., in response to) the first command (and possibly other commands) and information learned during training mode (e.g., based on one or more models or algorithms built during training mode). The second command can be associated with one or more memory operations (e.g., page operation, evict operation, prefetch operation). At 430, the second command can be communicated to TCQ circuit system 340. For example, ML engine 335 can communicate the second command to TCQ circuit system 340. At 435, a power mode command can be generated. For example, ML engine 335 can generate a power command based on or in response to the first command (and possibly other commands) and information learned during training mode. The power mode command can be used with volatile memory 320, non-volatile memory 325, or both.

[0098] At 440, a second command can be transmitted. For example, the ML engine 335 can transmit the second command to the TCQ circuitry 340. The TCQ circuitry 340 can then distribute the second command to the appropriate component of the interface controller 315. At 445, a power mode command can be transmitted. For example, the ML engine 335 can transmit the power mode command to the mode controller 345. If the power mode command is for the volatile memory 320, the ML engine 335 can transmit the power mode command to the mode controller of the volatile memory 320. If the power mode is for the non-volatile memory 325, the ML engine 335 can transmit the power mode command to the mode controller of the non-volatile memory 325. Based on or in response to the power mode command, the mode controller 345 can cause the volatile memory 320, the non-volatile memory 325, or both to enter a power mode indicated by a third command.

[0099] Alternative instances as described above can be implemented, in which some operations partially overlap, are executed in a different order than described, are executed in parallel, or are not executed at all. In some cases, operations may include additional features not mentioned herein, or additional operations may be added. Additionally, some operations may be executed multiple times, or certain combinations of operations may be repeated or cyclical.

[0100] Figure 5 A block diagram 500 is shown of a memory device 520 supporting machine learning for a multi-memory system, according to an example disclosed herein. The memory device 520 may be as described in the reference... Figures 1 to 4Examples of aspects of the described memory device. Memory device 520 or its various components may be examples of means for performing various aspects of machine learning for multi-memory systems as described herein. For example, memory device 520 may include decoder 525, ML engine 530, TCQ circuitry system 535, or any combination thereof. Each of these components may communicate with each other directly or indirectly (e.g., via one or more buses).

[0101] Decoder 525 may be or include a logic or circuit system capable of performing the functions described herein. In some instances, decoder 525 may be as described in the references... Figure 2 The decoder 228, or as referenced Figure 3 An example of the decoder 330 described herein. The ML engine 530 may be or include logic, circuitry, a controller, a processor, or other components capable of performing the functions described herein. In some instances, the ML engine 530 may be as described in the references... Figure 3 Examples of the ML engine 335 described herein. The TCQ circuit system 535 may be or include buffers, logic, circuitry, processors, controllers, or other components capable of performing the functions described herein. In some instances, the TCQ circuit system 535 may be as described in the references Figure 2 The command circuit system 230 described or as referenced Figure 3 An example of the described TCQ circuit system 340.

[0102] Decoder 525 may be configured or otherwise supported to support means for receiving a first command from a host device at an interface controller coupled to non-volatile and volatile memory. In some instances, decoder 525 may be configured or otherwise supported to support means for transmitting the first command to a machine learning engine and circuitry configured to store and manage the commands in the non-volatile and volatile memory. ML engine 530 may be configured or otherwise supported to support means for transmitting a second command generated by the machine learning engine to the circuitry, the second command being at least partially based on information determined by the machine learning engine during training mode. In some instances, the machine learning engine includes an LSTM neural network, a GRU neural network, a transformer neural network, or a combination thereof.

[0103] In some instances, the ML engine 530 may be configured or otherwise supported for means for grouping commands received from the host device during training mode by the machine learning engine based on one or more shared characteristics. In some instances, the ML engine 530 may be configured or otherwise supported for means for detecting one or more patterns associated with commands by the machine learning engine based at least in part on the grouping of commands, wherein the information determined by the machine learning engine is based at least in part on one or more patterns.

[0104] In some instances, one or more modes include one or more modes for operating an interface controller, non-volatile memory, volatile memory, or combinations thereof. In some instances, one or more shared characteristics include read bandwidth, write bandwidth, read distance, write distance, page open and close timing, read turnaround timing, write turnaround timing, reuse distance, evict frequency, or combinations thereof.

[0105] In some instances, the ML engine 530 may be configured or otherwise supported for means for determining a prefetch operation by the machine learning engine based at least in part on a first command and information determined during training mode, wherein the second command is associated with the prefetch operation, and the prefetch operation includes retrieving data from volatile or nonvolatile memory before the host device requests data.

[0106] In some instances, the ML engine 530 may be configured or otherwise supported for means for determining an eviction operation by the machine learning engine based at least in part on a first command and information determined during training mode, wherein the second command is associated with the eviction operation and the eviction operation includes storing data from volatile memory in non-volatile memory.

[0107] In some instances, the ML engine 530 may be configured or otherwise supported for means for the machine learning engine to determine a page open or page close operation based at least in part on a first command and information determined during training mode, wherein the second command is associated with the page open or page close operation.

[0108] In some instances, the ML engine 530 may be configured or otherwise supported for means for determining a power mode of non-volatile memory or volatile memory by the machine learning engine based at least in part on a first command and information determined during training. In some instances, the ML engine 530 may be configured or otherwise supported for means for transmitting a third command associated with the power mode to logic configured to control the power mode of volatile memory, the power mode of non-volatile memory, or both, via the machine learning engine.

[0109] In some instances, the interface controller includes a command decoder configured to simultaneously transmit a first command to both the machine learning engine and the circuitry. In some instances, the TCQ circuitry 535 may be configured or otherwise support means for storing a second command received from the machine learning engine. In some instances, the TCQ circuitry 535 may be configured or otherwise support means for transmitting the second command to a non-volatile memory or a scheduling component of volatile memory.

[0110] In some instances, a first command is received during a field mode in which the device operates on user data. In some instances, a first sequence of commands for training a machine learning engine is received during a training mode, and a second sequence of commands associated with the user data is received during the field mode. In some instances, the second command is generated at least in part based on information determined by the machine learning engine during the field mode.

[0111] Figure 6 A flowchart of a method 600 supporting machine learning for multi-memory systems, based on examples disclosed herein, is shown. Operation of method 600 can be implemented by a memory device or its components as described herein. For example, operation of method 600 can be performed by, as referenced... Figures 1 to 5 The memory device described is used for execution. In some instances, the memory device may execute a set of instructions to control the functional elements of the device to perform the described function. Additionally or alternatively, the memory device may use dedicated hardware to perform aspects of the described function.

[0112] At 605, the method may include receiving a first command from a host device at an interface controller coupled to non-volatile memory and volatile memory. Operation of 605 may be performed according to examples as disclosed herein. In some instances, aspects of operation of 605 may be provided by reference to [reference needed]. Figure 5 The decoder 525 described is used for execution.

[0113] In 610, the method may include a circuit system that transmits a first command to a machine learning engine and is configured to store and manage non-volatile memory and volatile memory. Operation of 610 may be performed according to examples disclosed herein. In some instances, aspects of the operation of 610 may be provided by reference to [reference needed]. Figure 5 The decoder 525 described is used for execution.

[0114] At 615, the method may include communicating a second command generated by a machine learning engine to the circuit system, the second command being at least partially based on information determined by the machine learning engine during training. Operation of 615 can be performed according to examples disclosed herein. In some instances, aspects of operation of 615 may be provided by reference to [reference needed]. Figure 5 The ML engine 530 described is used for execution.

[0115] In some instances, the device described herein can perform one or more methods, such as method 600. The device may include features, circuitry, logic, means, or instructions (e.g., a non-transitory computer-readable medium storing instructions executable by a processor) for receiving a first command from a host device at an interface controller coupled to non-volatile and volatile memory, communicating the first command to a machine learning engine and circuitry configured to store and manage commands for the non-volatile and volatile memory, and communicating a second command generated by the machine learning engine to the circuitry, the second command being at least partially based on information determined by the machine learning engine during training mode.

[0116] In some instances of the method 600 and device described herein, the machine learning engine includes an LSTM neural network, a GRU neural network, a transformer neural network, or a combination thereof. Some instances of the method 600 and device described herein may further include operations, features, circuit systems, logic, means, or instructions for grouping commands received from a host device during training modes by the machine learning engine based on one or more shared characteristics, and for detecting one or more patterns associated with commands by the machine learning engine based at least in part on the grouping of commands, wherein the information determined by the machine learning engine may be based at least in part on one or more patterns.

[0117] In some instances of the methods 600 and devices described herein, one or more modes include one or more modes for operating an interface controller, non-volatile memory, volatile memory, or combinations thereof. In some instances of the methods 600 and devices described herein, one or more shared characteristics include read bandwidth, write bandwidth, read distance, write distance, page open and close timing, read turnaround timing, write turnaround timing, reuse distance, evict frequency, or combinations thereof.

[0118] Some instances of the method 600 and device described herein may further include determining, by a machine learning engine, an operation, feature, circuitry, logic, means, or instruction of a prefetch operation based at least in part on a first command and information determined during a training mode, wherein a second command may be associated with the prefetch operation, and the prefetch operation includes retrieving data from volatile or nonvolatile memory prior to when the host device may request the data.

[0119] Some instances of the method 600 and device described herein may further include determining, by a machine learning engine, an operation, feature, circuit system, logic, means, or instruction of an eviction operation based at least in part on a first command and information determined during a training mode, wherein a second command may be associated with the eviction operation, and the eviction operation includes storing data from volatile memory in non-volatile memory.

[0120] Some instances of the method 600 and device described herein may further include operations, features, circuitry, logic, means, or instructions for determining a page open operation or page close operation by a machine learning engine based at least in part on a first command and information determined during training mode, wherein a second command may be associated with the page open operation or page close operation.

[0121] Some instances of the method 600 and device described herein may further include operations, features, circuitry, logic, means, or instructions for determining a power mode of non-volatile memory or volatile memory by a machine learning engine based at least in part on a first command and information determined during training mode, and for the machine learning engine to transmit a third command associated with the power mode to logic that may be configured to control the power mode of volatile memory, the power mode of non-volatile memory, or both.

[0122] In some instances of the method 600 and device described herein, the interface controller includes a command decoder configured to simultaneously transmit a first command to both the machine learning engine and the circuitry. Some instances of the method 600 and device described herein may further include operations, features, circuitry, logic, means, or instructions for storing a second command received from the machine learning engine and transmitting the second command to non-volatile or volatile memory.

[0123] In some instances of the methods 600 and devices described herein, a first command may be received during a field mode in which the device operates on user data. In some instances of the methods 600 and devices described herein, a first sequence of commands for training a machine learning engine may be received during a training mode, and a second sequence of commands associated with user data may be received during a field mode.

[0124] In some instances of the method 600 and device described herein, the second command may be generated at least in part based on information determined by a machine learning engine during field mode. It should be noted that the methods described herein describe possible implementations, and the operations and steps may be rearranged or otherwise modified, and other implementations are possible. Furthermore, portions of two or more of the methods may be combined.

[0125] An apparatus is described. The apparatus may include non-volatile memory, volatile memory configured to operate as a cache memory of the non-volatile memory, and an interface controller coupled to the non-volatile memory and the volatile memory, the interface controller being configured to cause the apparatus to receive a first command from a host device, to transmit the first command to a machine learning engine, and to a circuit system configured to store and manage commands for the non-volatile memory and the volatile memory, and to transmit a second command generated by the machine learning engine to the circuit system, the second command being at least partially based on information determined by the machine learning engine during a training mode.

[0126] In some instances of the device, the machine learning engine includes an LSTM neural network, a GRU neural network, a transformer neural network, or a combination thereof. In some instances of the device, the machine learning engine can be configured to group commands received from a host device during training mode based on one or more shared characteristics, and to detect one or more patterns associated with the commands based at least in part on the grouping of the commands, wherein the information determined by the machine learning engine can be based at least in part on one or more patterns.

[0127] In some instances of the device, one or more modes include one or more modes for operating the device. In some instances of the device, one or more shared characteristics include read bandwidth, write bandwidth, read distance, write distance, page open and close timing, read turnaround timing, write turnaround timing, reuse distance, eviction frequency, or combinations thereof.

[0128] In some instances, the device may include determining a prefetch operation based at least in part on a first command and information determined during training mode, wherein the second command may be associated with the prefetch operation, and the prefetch operation includes retrieving data from volatile or non-volatile memory before the host device can request the data.

[0129] In some instances, the device may include determining an eviction operation based at least in part on a first command and information determined during training mode, wherein the second command may be associated with the eviction operation, and the eviction operation includes storing data from volatile memory in non-volatile memory.

[0130] In some instances, the device may include determining a page open operation or a page close operation based at least in part on a first command and information determined during training mode, wherein the second command may be associated with the page open operation or the page close operation.

[0131] In some instances, the device may include determining a power mode for non-volatile memory or volatile memory based at least in part on a first command and information determined during training mode, and communicating a third command associated with the power mode to logic that can be configured to control the power mode of volatile memory, the power mode of non-volatile memory, or both.

[0132] In some instances of the device, the interface controller includes a command decoder configured to simultaneously transmit a first command to both the machine learning engine and the circuitry. In some instances, the device may include a scheduling component that stores a second command received from the machine learning engine and transmits the second command to non-volatile or volatile memory.

[0133] In some instances of the device, the first command may be received during a field mode in which the device operates on user data. In some instances of the device, a first command sequence for training a machine learning engine may be received during a training mode, and a second command sequence associated with user data may be received during the field mode. In some instances of the device, the second command may be generated at least in part based on information determined by the machine learning engine during the field mode.

[0134] Another device is described. The device may include non-volatile memory, volatile memory configured to operate as a cache memory of the non-volatile memory, and an interface controller coupled to the non-volatile memory and the volatile memory. The interface controller includes: a circuit system configured to store and manage commands for the non-volatile memory and the volatile memory; a command decoder configured to receive a first command from a host device and transmit the first command to the circuit system and a machine learning engine; and a machine learning engine configured to generate a second command based at least in part on information determined by the machine learning engine during a training mode and configured to transmit the second command to the circuit system.

[0135] In some instances of the device, the machine learning engine can be configured to group commands received from the host device during training mode based on one or more shared characteristics, and to detect one or more patterns associated with the commands based at least in part on the grouping of the commands, wherein the information determined by the machine learning engine can be based at least in part on one or more patterns.

[0136] In some instances, the device may include determining a prefetch operation based at least in part on a first command and information determined during training mode, wherein the second command may be associated with the prefetch operation, and the prefetch operation includes retrieving data from volatile or non-volatile memory before the host device can request the data.

[0137] In some instances, the device may include determining an eviction operation based at least in part on a first command and information determined during training mode, wherein the second command may be associated with the eviction operation, and the eviction operation includes storing data from volatile memory in non-volatile memory. In some instances, the device may include determining a page open operation or a page close operation based at least in part on a first command and information determined during training mode, wherein the second command may be associated with the page open operation or the page close operation.

[0138] In some instances, the device may include determining a power mode for non-volatile memory or volatile memory based at least in part on a first command and information determined during training mode, and communicating a third command associated with the power mode to logic configured to control the power mode of volatile memory, the power mode of non-volatile memory, or both.

[0139] Another device is described. The device may include: a circuit system configured to store and manage commands for non-volatile memory and volatile memory operating as a cache memory of non-volatile memory; a command decoder configured to receive a first command from a host device and transmit the first command to the circuit system and a machine learning engine; and a machine learning engine configured to generate a second command based at least in part on information determined by the machine learning engine during a training mode, and configured to transmit the second command to the circuit system.

[0140] In some instances of the device, the machine learning engine can be configured to group commands received from the host device during training mode based on one or more shared characteristics, and to detect one or more patterns associated with the commands based at least in part on the grouping of the commands, wherein the information determined by the machine learning engine may be based at least in part on one or more patterns. In some instances, the device may include determining a memory operation based at least in part on a first command and information determined during training mode, wherein the second command may be associated with a memory operation.

[0141] 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 above description can be represented by voltage, current, electromagnetic waves, magnetic fields or particles, light fields or particles, or any combination thereof. Some diagrams may show a signal as a single signal; however, those skilled in the art will understand that a signal can represent a bus of signals, wherein the bus can have various bit widths.

[0142] A protocol can define one or more communication procedures and one or more communication parameters supported for use by a device or component. For example, a protocol can define various operations, the timing and frequency for those operations, the meaning of various commands or signals or both, one or more addressing schemes for one or more memories, the type of communication where pins are reserved, the size of data processed at various components such as interfaces, the data rates supported by various components such as interfaces, or the bandwidth supported by various components such as interfaces, and other parameters and metrics, or any combination thereof. The use of shared protocols enables interaction between devices because each device can operate in a way that another device expects, recognizes, and understands. For example, two devices supporting the same protocol can interact according to the policies, procedures, and parameters defined by the protocol, while two devices supporting different protocols may be incompatible.

[0143] To illustrate, two devices supporting different protocols may be incompatible because the protocols define different addressing schemes (e.g., different numbers of address bits). As another illustration, two devices supporting different protocols can be incompatible because the protocols define different transmission procedures for responding to a single command (e.g., the burst length or number of bytes allowed in response to a command may be different). Simply translating a command into an action should not be interpreted as the use of two different protocols. Rather, the protocols can be considered different if the corresponding procedures or parameters defined by the two protocols change. For example, if a device supports different addressing schemes or different transmission procedures for responding to commands, the device can be said to support two different protocols.

[0144] The terms “electronic connectivity,” “conductive contact,” “connection,” and “coupling” can refer to a relationship between components that supports the flow of electrons between them. Components are considered electronically connected (or electrically contacting, connected, or coupled) to each other if any conductive path exists between them that can support the flow of signals between them at any given time. At any given time, based on (e.g., in response to) the operation of a device including the connected components, the conductive path between components that are electronically connected (or electrically contacting, connected, or coupled) to each other can be an open circuit or a closed circuit. The conductive path between connected components can be a direct conductive path between the components, or it can be 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.

[0145] 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 the change that allows signals to flow between other components via conductive paths that were previously not permitted.

[0146] 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 achieves the following change: preventing signals from flowing between the components using previously permitted conductive paths.

[0147] 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.

[0148] The switching components or transistors discussed in this document may represent field-effect transistors (FETs) and include a three-terminal device comprising a source, drain, and gate. 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 contain heavily doped, for example, degenerate, semiconductor regions. The source and drain may be separated by lightly doped semiconductor regions or channels. If the channel is n-type (i.e., most carriers are electrons), then the FET may be called an n-type FET. If the channel is p-type (i.e., most 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, will cause the channel to become conductive. If a voltage greater than or equal to the transistor's threshold voltage is applied to the transistor's gate, then the transistor may be "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 "off" or "deactivated."

[0149] 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.

[0150] 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 dash following the reference numeral and a second numeral used to differentiate them among similar components. 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.

[0151] 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 above description can be represented by voltage, current, electromagnetic waves, magnetic fields or particles, light fields or particles, or any combination thereof.

[0152] As used herein, the term “generally” means that a modified characteristic (e.g., a verb or adjective modified by the term “generally”) need not be absolute but must be close enough to obtain the advantage of the characteristic. As used herein, the term “simultaneously” means that the described actions or phenomena occur during a period of time that at least partially overlap in time; they may occur substantially simultaneously or may be offset in time.

[0153] The various illustrative blocks and modules described herein can be implemented or performed using a general-purpose processor, DSP, ASIC, FPGA or other programmable logic device, discrete gate or transistor logic, discrete hardware components, or any combination thereof designed to perform the functions described herein. A general-purpose processor may be a microprocessor, but alternatively, the processor may be any processor, controller, microcontroller, or state machine. The processor may also 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).

[0154] The functions described herein can be implemented in hardware, software executed by a processor, firmware, or any combination thereof. If implemented as software executed by a processor, the functions can be stored as one or more instructions or codes on or transmitted via a computer-readable medium. Other examples and embodiments 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 such that portions of the functions are implemented in different physical locations. Moreover, as used herein, including in the claims, the use of "or" in a list of items (e.g., a list of items beginning with phrases such as "at least one of" or "one or more of") indicates an inclusive list, such that, for example, a list of at least one of 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). Moreover, 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".

[0155] Computer-readable media includes both non-transitory computer storage media and communication media, including any media that facilitates the transfer of computer programs 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. Furthermore, any connection is properly referred to as computer-readable media. For example, if software is transmitted from a website, server, or other remote source using coaxial cable, fiber optic cable, twisted pair, digital subscriber line (DSL), or wireless technologies such as infrared, radio, and microwave, then the coaxial cable, fiber optic cable, twisted pair, digital subscriber line, or wireless technologies such as infrared, radio, and microwave are included in the definition of media. As used herein, disks and optical discs include CDs, laser discs, optical discs, DVDs, floppy disks, and Blu-ray discs, where disks typically reproduce data magnetically, while optical discs use lasers to reproduce data optically. Combinations of these are also included within the scope of computer-readable media.

[0156] 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 memory device comprising: Non-volatile memory; A volatile memory configured to operate as a cache memory for the non-volatile memory; as well as An interface controller, coupled to the non-volatile memory and the volatile memory, is configured to cause the memory device to: Receive the first command from the host device; The first command is transmitted to a machine learning engine and a circuit system configured to store and manage commands for the non-volatile memory and the volatile memory, wherein the machine learning engine is configured to: Commands received from the host device during training mode are grouped according to one or more shared characteristics. and The detection of one or more patterns associated with the commands is based at least in part on grouping the commands. as well as A second command generated by the machine learning engine is transmitted to the circuit system, the second command being at least partially based on information determined by the machine learning engine during the training mode, wherein the information determined by the machine learning engine is at least partially based on the one or more modes.

2. The memory device of claim 1, wherein the machine learning engine comprises a Long Short-Term Memory (LSTM) neural network, a Gated Recurrent Unit (GRU) neural network, a Transformer Neural Network, or a combination thereof.

3. The memory device of claim 1, wherein the one or more modes include one or more modes for operating the memory device.

4. The memory device of claim 1, wherein the one or more shared features include read bandwidth, write bandwidth, read distance, write distance, page open and close timing, read turnaround timing, write turnaround timing, reuse distance, evict frequency, or a combination thereof.

5. The memory device of claim 1, wherein the interface controller includes a command decoder configured to simultaneously transmit the first command to the machine learning engine and the circuit system.

6. The memory device of claim 1, wherein the circuitry is configured as follows: Store the second command received from the machine learning engine; and The second command is transmitted to the non-volatile memory or the scheduling component of the volatile memory.

7. The memory device of claim 1, wherein the first command is received during a field mode in which the memory device operates on user data, and wherein a first command sequence for training the machine learning engine is received during a training mode, and a second command sequence associated with the user data is received during the field mode.

8. The memory device of claim 7, wherein the second command is generated at least in part based on information determined by the machine learning engine during the live mode.

9. A memory device comprising: Non-volatile memory; A volatile memory configured to operate as a cache memory for the non-volatile memory; as well as An interface controller, coupled to the non-volatile memory and the volatile memory, is configured to cause the memory device to: Receive the first command from the host device; The first command is transmitted to a machine learning engine and a circuit system configured to store and manage commands for the non-volatile memory and the volatile memory, wherein the machine learning engine is configured to: The prefetch operation is determined at least in part based on the first command and information determined by the machine learning engine during training mode; as well as A second command generated by the machine learning engine is communicated to the circuit system, wherein the second command is based at least in part on the information determined by the machine learning engine during the training mode, and wherein the second command is associated with the prefetch operation, and the prefetch operation includes retrieving the data from the volatile memory or the non-volatile memory before the host device requests the data.

10. A memory device comprising: Non-volatile memory; A volatile memory configured to operate as a cache memory for the non-volatile memory; as well as An interface controller, coupled to the non-volatile memory and the volatile memory, is configured to cause the memory device to: Receive the first command from the host device; The first command is transmitted to a machine learning engine and a circuit system configured to store and manage commands for the non-volatile memory and the volatile memory, wherein the machine learning engine is configured to: The eviction operation is determined at least in part based on the first command and information determined by the machine learning engine during training mode; as well as A second command generated by the machine learning engine is communicated to the circuit system, wherein the second command is based at least in part on the information determined by the machine learning engine during the training mode, and wherein the second command is associated with the eviction operation, and the eviction operation includes storing data from the volatile memory in the non-volatile memory.

11. A memory device comprising: Non-volatile memory; A volatile memory configured to operate as a cache memory for the non-volatile memory; as well as An interface controller, coupled to the non-volatile memory and the volatile memory, is configured to cause the memory device to: Receive the first command from the host device; The first command is transmitted to a machine learning engine and a circuit system configured to store and manage commands for the non-volatile memory and the volatile memory, wherein the machine learning engine is configured to: The page open operation or page close operation is determined at least in part based on the first command and information determined by the machine learning engine during training mode; as well as A second command generated by the machine learning engine is communicated to the circuit system, wherein the second command is based at least in part on the information determined by the machine learning engine during the training mode, and wherein the second command is associated with the page open operation or the page close operation.

12. A memory device comprising: Non-volatile memory; A volatile memory configured to operate as a cache memory for the non-volatile memory; as well as An interface controller, coupled to the non-volatile memory and the volatile memory, is configured to cause the memory device to: Receive the first command from the host device; The first command is transmitted to a machine learning engine and a circuit system configured to store and manage commands for the non-volatile memory and the volatile memory, wherein the machine learning engine is configured to: The power mode of the non-volatile memory or the volatile memory is determined at least in part based on the first command and information determined by the machine learning engine during training mode; A second command generated by the machine learning engine is transmitted to the circuit system, wherein the second command is based at least in part on the information determined by the machine learning engine during the training mode; And to transmit a third command associated with the power mode to logic configured to control the power mode of the volatile memory, the power mode of the non-volatile memory, or both.

13. A memory device comprising: Non-volatile memory; A volatile memory configured to operate as a cache memory for the non-volatile memory; as well as An interface controller coupled to the non-volatile memory and the volatile memory, the interface controller comprising: The machine learning engine is configured as follows: Grouping commands received from the host device during training mode based on one or more shared characteristics; and The detection of one or more patterns associated with the commands is based at least in part on grouping the commands. A circuit system configured to store and manage commands for the non-volatile memory and the volatile memory; as well as A command decoder is configured to receive a first command from the host device and transmit the first command to the circuit system and the machine learning engine, wherein the machine learning engine is further configured to: The second command is generated at least in part based on information determined by the machine learning engine during the training mode, at least in part based on one or more modes. as well as The second command is transmitted to the circuit system.

14. The memory device of claim 13, wherein the machine learning engine is configured to: The prefetch operation is determined at least in part based on the first command and the information determined during the training mode, wherein the second command is associated with the prefetch operation, and the prefetch operation includes retrieving the data from the volatile memory or the non-volatile memory before the host device requests the data.

15. The memory device of claim 13, wherein the machine learning engine is configured to: The eviction operation is determined at least in part based on the first command and the information determined during the training mode, wherein the second command is associated with the eviction operation and the eviction operation includes storing data from the volatile memory in the non-volatile memory.

16. The memory device of claim 13, wherein the machine learning engine is configured to: The page open operation or page close operation is determined at least in part based on the first command and the information determined during the training mode, wherein the second command is associated with the page open operation or the page close operation.

17. The memory device of claim 13, wherein the machine learning engine is configured to: The power mode of the non-volatile memory or the volatile memory is determined at least in part based on the first command and the information determined during the training mode; and A third command associated with the power mode is communicated to logic configured to control the power mode of the volatile memory, the power mode of the non-volatile memory, or both.

18. A memory device comprising: A circuit system configured to store and manage commands for non-volatile memory and volatile memory operating as a cache memory that is non-volatile memory. A command decoder is configured to receive a first command from a host device and transmit the first command to the circuit system and the machine learning engine. as well as The machine learning engine is configured as follows: Commands received from the host device during training mode are grouped according to one or more shared characteristics. The detection of one or more patterns associated with the commands is based at least in part on grouping the commands. The second command is generated based at least in part on information determined by the machine learning engine during the training mode, wherein the information determined by the machine learning engine is at least in part based on the one or more modes; as well as The second command is transmitted to the circuit system.

19. The memory device of claim 18, wherein the machine learning engine is configured to: The memory operation is determined at least in part based on the first command and the information determined during the training mode, wherein the second command is associated with the memory operation.

Citation Information

Patent Citations

  • Predictive Data Pre-Fetching in a Data Storage Device

    US20200326851A1