Dynamic single-level cell write-through in memory devices

A dynamic SLC cache in memory devices adjusts its operation based on host workload to optimize write operations, addressing inefficiencies in multi-level cell memory systems and enhancing performance and cost-effectiveness.

JP2026539100APending Publication Date: 2026-11-19SK HYNIX NAND PRODUCT SOLUTIONS CORP
View PDF 0 Cites 0 Cited by

Patent Information

Application Number
JP2026528151
Authority / Receiving Office
JP · JP
Patent Type
Applications
Current Assignee / Owner
Priority Date
2023-11-10
Filing Date
2024-11-07
Publication Date
2026-11-19

AI Technical Summary

Technical Problem

Existing memory devices face challenges in efficiently managing data writes across various scenarios, including small and large write operations, leading to inefficiencies in write cycles and increased operational costs due to the need for data aggregation in multi-level cell memory systems.

Method used

Implementing a dynamic single-level cell (SLC) cache that adjusts its enablement and size based on the host device's workload, converting between SLC and x-level cells (XLC) to optimize write operations, and dynamically adjusting the number of SLC bands or cache size to match the host's write shaping state.

Benefits of technology

Enhances the efficiency and cost-effectiveness of memory operations by adapting to different write scenarios, reducing the need for data aggregation and optimizing performance and durability in multi-level cell memory systems.

✦ Generated by Eureka AI based on patent content.

Smart Images

  • Figure 2026539100000001_ABST
    Figure 2026539100000001_ABST
Patent Text Reader

Abstract

This application aims to write data to a memory device that supports multiple bits per cell by dynamically using a y-level cell (YLC) cache. The memory device is coupled to a host device and contains multiple x-level cell (XLC) memory blocks (where x is greater than 1 and y is greater). The memory device identifies the write shaping state of the host device. Based on the write shaping state, the memory device determines that the host device will perform a write operation without a memory-based cache. In response to the determination that the host device will perform a write operation without a memory-based cache, the memory device allocates a YLC cache within itself to function as a memory-based cache. In response to one or more write requests, the memory device stores data in the multiple XLC memory blocks via the YLC cache.
Need to check novelty before this filing date? Find Prior Art

Description

TECHNICAL FIELD

[0001] (CROSS-REFERENCE TO RELATED APPLICATIONS) This application is a continuation of, and claims priority to, U.S. Patent Application No. 18 / 388,782, filed on November 10, 2023, entitled "Dynamic Single-Level Cell Write Through in Memory Devices", the entire content of which is incorporated herein by reference.

[0002] The present application relates generally to data write-through, including but not limited to methods, systems, and non-transitory computer-readable media for writing data to a memory device that stores multiple bits per cell using a single-level cell (SLC) cache dynamically. BACKGROUND ART

[0003] Memory is applied to computer systems to store instructions and data. In particular, when disconnected from power, computer systems retain stored instructions and data through non-volatile memory. Examples of non-volatile memory include, but are not limited to, hard disk drives (HDDs) and solid-state drives (SSDs). SSDs store data in NAND memory, which continues to evolve with higher data density to meet the demands of businesses and consumers for high-capacity, high-performance, and cost-effective data storage. The number of states within a memory cell increases from 1 bit per cell (i.e., 2 possible states) in single-level cell (SLC) to multiple bits per cell. For example, NAND memory with 4 possible states per cell is called multi-level cell (MLC) memory and may represent 2 bits of data per cell. NAND memory with 8 possible states per cell is called triple-level cell (TLC) memory and may represent 3 bits of data per cell. NAND memory with 16 possible states per cell is called quad-level cell (QLC) memory and may represent 4 bits of data per cell. Furthermore, NAND memory with 32 possible states per cell is called pentalevel cell (PLC) memory and may represent 5 bits of data per cell. In one scenario, memory supporting multiple bits per cell receives write data in small areas, and these small writes need to be aggregated until enough data is obtained to complete the entire write cycle. In another scenario, memory supporting multiple bits per cell receives write data in large areas, and the write cycle can be completed directly without data aggregation. It would be beneficial to develop a mechanism for managing data writes in memory devices of electronic systems to operate in all of these scenarios. [Overview of the Initiative]

[0004] Various embodiments of this application are directed towards methods, systems, devices, and non-transient computer-readable media for writing data to a memory device that stores multiple bits per cell using an SLC cache dynamically. The memory device is coupled to a host device in an electronic system (e.g., a computer system). In some embodiments, firmware within the memory device dynamically detects the host workload of the host device to determine whether write shaping is to be used. Based on this identification, the SLC cache is enabled or disabled. In some embodiments, the write band is instantly converted between SLC and x-level cells (XLC). In some embodiments, the number of SLC bands or the size of the SLC cache is dynamically adjusted based on the host workload.

[0005] In one embodiment, the method is carried out in an electronic device or memory system including a host device and a memory device. The method includes identifying the write shaping state of the host device. The memory device is coupled to the host device and includes a plurality of XLC memory blocks (x greater than 1). The method further includes determining, based on the write shaping state, that the host device will perform a write operation without a memory-based cache. The method further includes allocating an SLC cache within the memory device to function as the memory-based cache in response to the determination that the host device will perform a write operation without the memory-based cache. The method further includes storing data in the plurality of XLC memory blocks via the SLC cache within the memory device in response to one or more write requests.

[0006] In some embodiments, identifying the write shaping state includes determining the write shaping state of the host device by having the memory device receive a notification from the host device and determining, based on the notification, whether the host device supports write operations through the memory-based cache. If the host device does not support write operations through the memory-based cache, the SLC cache is allocated to write data to the memory device.

[0007] In some embodiments, identifying the write shaping state includes determining the write shaping state of the host device by having the memory device receive at least one write command for writing host data from the host device, detecting an input / output (I / O) pattern based on the at least one write command, and determining whether the I / O pattern indicates a sequential data area or a random data area relative to the logical block addressing (LBA). If the I / O pattern indicates a random data area relative to the LBA, the SLC cache is allocated to write data to the memory device.

[0008] Some implementations of this application include a memory device comprising a plurality of XLC memory blocks (x greater than 1), an SLC cache, and a memory controller operable to execute instructions, wherein when the instructions are executed, the memory controller causes the memory controller to perform any of the methods described above on a memory system (e.g., including one or more SSDs).

[0009] Some implementations of this application include an electronic system comprising a host device and a memory device coupled to the host device and configured to perform any of the methods described above on a memory system (e.g., including one or more SSDs).

[0010] Some implementations include a non-temporary computer-readable storage medium that stores one or more programs. When executed by one or more processors, the one or more programs include instructions that cause the processors to perform any of the methods described above on a memory system (e.g., including one or more SSDs).

[0011] These exemplary embodiments and implementations mentioned herein are not intended to limit or restrict the disclosure, but rather to provide examples that aid in understanding it. Additional embodiments are considered in forms for carrying out the invention and further explanation is provided.

[0012] To better understand the various implementation forms described, please refer to the following drawings and the embodiments for carrying out the invention. In the drawings, similar reference numbers refer to the corresponding parts throughout the drawings. [Brief explanation of the drawing]

[0013] [Figure 1] This is a block diagram of an exemplary system module in a typical electronic system according to some embodiments of this teaching. [Figure 2] This is a block diagram of an exemplary electronic device memory system having one or more memory access queues, according to some embodiments of this teaching. [Figure 3] This is a block diagram of an exemplary electronic system according to some embodiments of this instruction. [Figure 4] This is a block diagram of an exemplary memory system, including an SLC cache, that supports multiple bits per cell, according to some embodiments of this teaching. [Figure 5] This flowchart illustrates an exemplary method, according to some embodiments of this teaching, for dynamically enabling or disabling an SLC cache in a memory device based on the write shaping state of a host device. [Figure 6]This is a flowchart illustrating an exemplary method for dynamically adjusting the size of an SLC cache in a memory device based on the write shaping state of a host device, according to some embodiments of this teaching. [Modes for carrying out the invention]

[0014] Similar reference numbers refer to the corresponding parts throughout multiple drawings in the overall drawing.

[0015] Specific embodiments are described in detail below, examples of which are shown in the accompanying drawings. In the following detailed description, numerous non-limiting and specific details are included to aid in understanding the subject matter presented herein. However, it will be obvious to those skilled in the art that various alternative forms may be used without departing from the claims, and that the subject matter may be practiced without these specific details. For example, it will be obvious to those skilled in the art that the subject matter presented herein can be implemented in any kind of electronic system or device having data storage capabilities.

[0016] As NAND memory (e.g., SSDs) evolves from SLC to MLC, TLC, QLC, and PLC, and data density increases, more and more data is required to complete a full programming or write cycle. For example, PLC media may require 5 to 10 megabytes (MB) of data to complete a full multipath programming cycle. In some use cases, storage servers in modern data centers shape large write areas to SSDs to reduce or eliminate garbage collection, in which case there is enough available data to complete a PLC programming cycle. In other use cases, legacy storage hosts do not shape writes, so SSDs receive write data as small as a single sector. In these use cases, SSDs need to aggregate these small writes until there is enough data to complete a PLC programming cycle.

[0017] Various embodiments of this teaching are directed towards methods, systems, devices, and non-transient computer read media for writing data to memory devices that support multiple bits per cell by dynamically using a portion of the memory device as an SLC write cache. In some embodiments, the memory device includes a single dynamic firmware, which simplifies operation and reduces costs for both the in-house and the customer. This enables the memory device (e.g., SSD) to function dynamically and automatically in any of the use cases described above. In some embodiments, the single dynamic firmware dynamically detects the workload of the host device coupled to the memory device and identifies whether write shaping is used. Depending on the determination of whether write shaping is used, the SLC write cache is enabled or disabled and the band is instantly converted between SLC and PLC. The size of the SLC write cache is dynamically adjusted based on the host workload. The following description focuses on memory devices that support PLC, but it can be understood that the same systems and methods are applicable to other memory devices that support multiple bits per cell, such as MLC, TLC, QLC, and XLC (x-level cells). The following explanation focuses on memory devices that support XLC (x-level cells) in a dynamic SLC write cache, but it should be understood that the same system and method apply to other memory devices that support XLC (x-level cells) in a dynamic YLC (y-level cells) (where y is less than x) write cache.

[0018] In some embodiments, write shaping involves consolidating small writes into larger writes. Write shaping may be performed by the host device or by the memory device. When the host device shapes writes, it does so in the write cache within the host device. When the memory device shapes writes, the SLC cache is enabled to shape writes.

[0019] In some embodiments, write shaping occurs on the host device, accumulating a very large amount of data before sending write commands to the memory device. For example, the host may accumulate 1GB of write data before sending it to the memory device. The 1GB buffer is contiguous or scattered in host memory (write cache within the host device). In some embodiments, the entire buffer is sequential with respect to logical block addressing (LBA). The host may employ multiple writers / workers to send data to the memory device. Each writer typically sends a different section within the large write buffer. The LBA is sequential or pseudo-sequential from the starting point. In some cases, host-based write shaping is performed by the host device, and the memory device receives multiple streams of sequential write commands. In some cases, the host's write workload is random, and there is no write shaping on the host device.

[0020] In some embodiments, the host device and memory device negotiate operating parameters, for example via Non-Volatile Memory Express (NVMe), identify the Controller (IDC) protocol, and, when adopting the NVMe standard, detect host-based write shaping during device discovery. Furthermore, under certain circumstances, the host device identifies itself as write-shapeable, and the memory device disables SLC write-through, i.e., writes data to the PLC block without creating or using the SLC write cache. In some embodiments, the host device identifies itself as not supporting host-based write shaping. The memory device enables SLC write-through, i.e., writes data to the PLC block via the SLC write cache. In some embodiments, the host device also communicates write bandwidth requirements in the form of the required burst and / or sustained MB data per second, thereby allowing the memory device to adjust the size of the SLC write cache within the memory device.

[0021] In some embodiments, host-based write shaping is detected during processing of write input / output (I / O) commands. In some cases, a memory device detects a write I / O pattern indicative of host-based write shaping, in which write commands describe a large sequential data region, and triggers disabling of SLC write-through. Accordingly, the memory device writes data to PLC blocks without creating or using an SLC write cache (referred to as a shaping write mode), and converts any SLC bands back to PLC. In some cases, the memory device detects a purely random write I / O pattern and enables SLC write-through. Accordingly, the memory device converts the corresponding media band to SLC, and writes data to PLC blocks via the SLC write cache that includes the SLC band (referred to as an SLC write-through mode). In some embodiments, a memory device operating in SLC write-through mode responds to write commands in a different manner than a memory device operating in shaping write mode. A memory device operating in SLC write-through mode responds to host write commands individually and very quickly. A memory device operating in shaping write mode consumes and processes a large amount of write data before responding to a write command.

[0022] In some embodiments, the number of SLC bands and / or the size of the SLC write cache is dynamic depending on the operation of the host device and the write pressure applied to the memory device. When the host device supplies write pressure in bursts, the memory device requires a small SLC cache. When the host device supplies more sustained write pressure, the memory device requires a large SLC cache to absorb the workload.

[0023] Figure 1 is a block diagram of an exemplary system module 100 in a typical electronic system according to several embodiments. The system module 100 in this electronic system includes at least a processor module 102, a memory module 104 for storing programs, instructions, and data, an input / output (I / O) controller 106, one or more communication interfaces such as a network interface 108, and one or more communication buses 140 for interconnecting these components. In some embodiments, the I / O controller 106 enables the processor module 102 to communicate with I / O devices (e.g., a keyboard, mouse, or trackpad) via a universal serial bus interface. In some embodiments, the network interface 108 includes one or more interfaces for Wi-Fi, Ethernet, and Bluetooth networks, each interface enabling the electronic system to exchange data with an external source, such as a server or another electronic system. In some embodiments, the communication bus 140 includes circuitry (sometimes called a chipset) that interconnects the various system components included in the system module 100 and controls communication between them.

[0024] In some embodiments, the memory module 104 includes high-speed random access memory, such as dynamic random access memory (DRAM), static random access memory (SRAM), double data rate (DDR) DRAM, or other random access solid-state memory devices. In some embodiments, the memory module 104 includes non-volatile memory, such as one or more magnetic disk storage devices, optical disk storage devices, flash memory devices, or other non-volatile solid-state storage devices. In some embodiments, the memory module 104, or alternatively the non-volatile memory device within the memory module 104, comprises a non-transitory computer-readable storage medium. In some embodiments, a memory slot is reserved on the system module 100 to accommodate the memory module 104. When inserted into the memory slot, the memory module 104 is integrated into the system module 100.

[0025] In some embodiments, the system module 100 further includes one or more components selected from a memory controller 110, an SSD 112, a hard disk drive (HDD) 114, a power management integrated circuit (PMIC) 118, a graphics module 120, and a sound module 122. The memory controller 110 is configured to control communication between the processor module 102 and the memory components, including the memory module 104, in the electronic system. The SSD 112 is configured to apply an integrated circuit assembly to store data in the electronic system, and in many embodiments, is based on a NAND or NOR memory configuration. The HDD 114 is a conventional data storage device for storing and retrieving digital information based on an electromechanical magnetic disk. The power connector 116 is electrically coupled to receive an external power supply. The PMIC 118 is configured to modulate the received external power supply to other desired DC voltage levels, such as 5V, 3.3V, or 1.8V, as required by various components or circuits in the electronic system (e.g., the processor module 102). The graphics module 120 is configured to generate a feed of output images to one or more display devices, depending on the desired image / video format of one or more display devices. The sound module 122 is configured to facilitate the input of audio signals to and output of audio signals from the electronic system, under the control of a computer program. The communication bus 140 also interconnects various system components, including components 110-122, and controls communication between them.

[0026] Furthermore, those skilled in the art will understand that as new data storage technologies are developed to store information in non-temporary computer-readable storage media within the SSD 112 and memory module 104, other non-temporary computer-readable storage media may be used. Although each of these data storage technologies is currently under development and not yet commercialized, these new non-temporary computer-readable storage media include, but are not limited to, those manufactured from biomaterials, nanowires, carbon nanotubes, and individual molecules.

[0027] Figure 2 is a block diagram of a memory system 200 of an exemplary electronic system having one or more memory access queues according to several embodiments. The memory system 200 is coupled to a host device 220 (e.g., a processor module 102 in Figure 1) and is configured to store instructions and data for extended periods, for example, when the electronic system is in sleep, hibernation, or shutdown mode. The host device 220 is configured to access the instructions and data stored in the memory system 200 and process these instructions and data to operate an operating system and run user applications. The memory system 200 further includes a memory controller 202 and a plurality of memory channels 204 (e.g., channels 204A, 204B, and 204N). Each memory channel 204 contains a plurality of memory cells. The memory controller 202 is configured to run firmware-level software to bridge the plurality of memory channels 204 to the host device 220. In some embodiments, the set of memory channels 204 forms a memory device (e.g., an SSD). In some embodiments, the memory system 200 includes one or more memory devices.

[0028] Each memory channel 204 contains one or more memory packages. In one example, each memory package contains a memory die 206 (e.g., memory die 206A or 206B). In another example, each memory package has two or more memory dies 206. Each memory package contains multiple memory planes 208, and each memory plane 208 further contains multiple memory pages 210. Each memory page 210 contains an ordered set of memory cells, each memory cell identified by a separate physical address.

[0029] In some examples, a memory device includes eight memory channels 204, each memory channel 204 further including eight memory dies 206. Each memory die 206 includes two memory planes 208 or arrays. Each memory plane 208 further includes multiple memory pages 210. Each memory page 210 includes an ordered set of memory cells, each memory cell identified by a separate physical address.

[0030] In some embodiments, the memory system 200 includes an SLC NAND flash memory chip, where each memory cell stores a single data bit. In some embodiments, the memory system 200 includes a multi-level cell (MLC) NAND flash memory chip, where each memory cell stores two data bits. In one example, each memory cell of a triple-level cell (TLC) NAND flash memory chip stores three data bits. In another example, each memory cell of a quad-level cell (QLC) NAND flash memory chip stores four data bits. In yet another example, each memory cell of a penta-level cell (PLC) NAND flash memory chip stores five data bits. In some embodiments, each memory cell may store any appropriate number of data bits. Compared to non-SLC NAND flash memory chips (e.g., MLC SSDs, TLC SSDs, QLC SSDs, PLC SSDs), SSDs with SLC NAND flash memory chips operate at higher speeds, higher reliability, and longer service life, but have lower device density and higher prices.

[0031] Each memory channel 204 is coupled to a separate channel controller 214 (e.g., channel controllers 214A, 214B, or 214N) configured to control internal and external requests for accessing memory cells within each memory channel 204. In some embodiments, each memory package (e.g., each memory die) corresponds to a separate queue 216 (e.g., queues 216A, 216B, or 216N) of memory access requests. In some embodiments, each memory channel 204 corresponds to a separate queue 216 of memory access requests. Furthermore, in some embodiments, each memory channel 204 corresponds to a distinct queue 216 of memory access requests. In some embodiments, a subset (less than all) of multiple memory channels 204 correspond to distinct queues 216 of memory access requests. In some embodiments, all of the multiple memory channels 204 of the memory system 200 correspond to a single queue 216 of memory access requests. Each memory access request is optionally received internally from the memory system 200 to manage a separate memory channel 204, or externally from the host device 220 to write to or read data stored in the separate channel 204. Specifically, each memory access request includes one of the following: a system write request received from the memory system 200 for writing to a separate memory channel 204, a system read request received from the memory system 200 for reading from a separate memory channel 204, a host write request obtained from the host device 220 for writing to a separate memory channel 204, and a host read request received from the host device 220 for reading from a separate memory channel 204. Note that system read requests (also called background read requests or non-host read requests) and system write requests are dispatched by the memory controller to perform internal memory management functions, including but not limited to garbage collection, wear leveling, read disturb mitigation, memory snapshot capture, memory mirroring, caching, and memory sparing.

[0032] In some embodiments, in addition to the channel controller 214, the memory controller 202 further includes a memory processor 218, a host interface controller 222, an SRAM buffer 224, and a DRAM controller 226. The memory processor 218 accesses multiple memory channels 204 based on one or more queues 216 of memory access requests. In some embodiments, the memory processor 218 writes to and reads from multiple memory channels 204 in memory block units. Data in one or more memory blocks is jointly written to or read from multiple channels. Data within the same memory block is not written simultaneously by more than one operation. Each memory block corresponds to arbitrarily one or more memory pages. In one example, the size of each memory block jointly written to or read from multiple memory channels 204 is 16KB (e.g., one memory page). In another example, the size of each memory block jointly written to or read from multiple memory channels 204 is 64KB (e.g., four memory pages). In some embodiments, each page has 16KB of user data and 2KB of metadata. Furthermore, the number of memory blocks accessed jointly and the size of each memory block can be configured for each of the system read, host read, system write, and host write operations.

[0033] In some embodiments, the memory processor 218 stores data written to or read from each memory block in the multiple memory channels 204 in the SRAM buffer 224 of the memory controller 202. Alternatively, in some embodiments, the memory processor 218 stores data written to or read from each memory block in the multiple memory channels 204 in the DRAM buffer 228 of the memory system 200. Alternatively, in some embodiments, the memory processor 218 stores data written to or read from each memory block in the multiple memory channels 204 in the DRAM buffer 228, which is the main memory used by the processor module 102 (Figure 1). The memory processor 218 of the memory controller 202 accesses the DRAM buffer 228 via the host interface controller 222.

[0034] In some embodiments, data within multiple memory channels 204 are grouped into coded blocks, each coded block being called a codeword. For example, each codeword contains n bits, of which k bits correspond to user data and (nk) corresponds to integrity data for the user data (where k and n are positive integers). In some embodiments, the memory system 200 includes an integrity engine 230 (e.g., an LDPC engine) and a register 232 coupled to the integrity engine 230, which includes multiple registers, or SRAM cells, or flip-flops. The integrity engine 230 is coupled to the memory channels 204 via a channel controller 214 and an SRAM buffer 224. Specifically, in some embodiments, the integrity engine 230 has a data path connection to the SRAM buffer 224, which is further connected to the channel controller 214 via a data path controlled by a memory processor 218. The integrity engine 230 is configured to verify the data integrity of each encoded block in memory channel 204 using variable nodes and check nodes, and messages are exchanged between the variable nodes and check nodes during the integrity check process. A subset of these messages is selected and temporarily stored in register 232 as variable node data or check node data.

[0035] In various embodiments of this application, the memory controller 202 is coupled to a local controller 280 located within a memory package, a memory die 206, or a memory plane 208. The memory system 200 includes a plurality of memory packages. In at least a subset of the memory packages, each corresponding memory package includes a local controller 280 for monitoring and reporting the validity conditions of its pages. The local controller 280 is configured to receive queries from the memory controller 202 for the validity conditions of the pages of the corresponding memory package, verify the data integrity of each codeword in the subset of pages, and determine the page error parameters based on the validity results of this subset of pages. The page error parameters are determined locally within the local controller 280 and reported to the memory controller 202 via an input / output (I / O) bus. These means allow the memory controller 202 to send queries for the validity conditions of the pages of the memory device and receive error parameters via an I / O bus connected to a memory channel 204, without having to transmit memory data via the I / O bus.

[0036] Figure 3 is a block diagram of an exemplary electronic system 300 according to several embodiments. The electronic system 300 includes a host device 220 (e.g., a processor module 102 in Figure 1) and a memory system 200 coupled to the host device 220. The memory system 200 is configured to store instructions and data for extended periods, for example, when the electronic system 300 is in sleep, hibernation, or shutdown mode. The host device 220 is configured to access the instructions and data stored in the memory system 200, process these instructions and data to operate an operating system, and run user applications. The memory system 200 further includes a plurality of memory blocks 302. Each memory block 302 includes one or more memory pages 210, each having a plurality of memory cells. A memory controller 202 is configured to run firmware-level software to bridge the plurality of memory blocks 302 to the host device 220.

[0037] In some embodiments, the electronic system 200 includes an SLC cache 304 containing one or more memory blocks. The memory blocks within the SLC cache 304 are subsets of a plurality of memory blocks 302, i.e., the SLC cache 304 covers subsets of dies 411, 412, and 413. In some embodiments, the memory controller 202 selects a subset of memory blocks to form the SLC cache 304. In some embodiments, the SLC cache 304 is formed by a portion of each of the subsets of memory blocks. In some embodiments, the remaining or unselected memory blocks 302 outside the SLC cache 304 form the XLC main memory section 310.

[0038] In some embodiments, each of the multiple memory blocks 302 is initially configured to store multiple bits per cell, for example, 5 bits per cell, as a PLC memory block. When one of the multiple memory blocks 302 is selected as part of the SLC cache 304, the selected memory block stores a single bit per cell. For example, the selected memory block is converted from a PLC type block to an SLC type block. In some embodiments, part of the selected memory block includes a set of memory cells, and each cell in the set of memory cells is converted from a PLC type cell to an SLC type cell. In some embodiments, most of the multiple memory blocks 302 are initially configured to store multiple bits per cell, for example, 5 bits per cell, as PLC memory blocks in the XLC main memory unit 310, but some of the multiple memory blocks 302 are initially configured to store a single bit per cell as SLC blocks in the SLC cache 304. In some embodiments, after initial setup, memory blocks or memory cells are dynamically selected as part of the XLC main memory unit 310 or the SLC cache 304.

[0039] As mentioned above, PLC memory devices may require 5-10MB of data to complete a full multipath programming cycle. In some scenarios, the host device can supply 5-10MB of data per die. In other scenarios, the host device cannot supply so much data at once. The SLC cache 304 can be used as a write memory cache to accumulate small writes up to 5-10MB of program data in order to complete a write cycle of the PLC memory.

[0040] In some use cases, the host device 220, being a host within a personal computer (PC), sends small burst write data of 512 bytes or more to the memory system 200. In some use cases, the host device 220, being a host within a data center (DC) server, sends larger persistent write data, for example, 5MB, 10MB, or more, to the memory system 200. In some use cases, the host device 220 directs write data to different bands and / or dies in a placement mode such as Flexible Data Placement (FDP) mode. Each use case requires a different configuration for the SLC cache 304. For example, a small SLC cache is sufficient in a PC, but a larger SLC cache is desirable in a DC server. Some DC servers do not require an SLC cache. Also, in placement modes that reduce or eliminate internal garbage collection in the memory system 200, an SLC cache may not be feasible.

[0041] Thus, in some embodiments, the SLC cache 304 is configured as a dynamic cache that may or may not be activated during a data write cycle of the memory system 200. In some embodiments, each of the plurality of memory blocks 302 is an XLC memory block that stores x bits (where x is greater than 1) per cell. The memory system 200 identifies the write shaping state of the host device 220, for example, by the memory controller 202. Based on the write shaping state, the memory system 200 determines whether the host device 220 will perform a write operation with or without a memory-based cache. In response to the determination that the host device 220 will perform a write operation without a memory-based cache, the SLC cache 304 is allocated to the memory system 200, activated, and functions as a memory-based cache. In response to one or more write requests 312, the memory system 200 stores data in the plurality of XLC memory blocks in the XLC main memory section 310 via the SLC cache 304.

[0042] In some embodiments, the write shaping state of the host device 220 is identified by the memory system 200 receiving a notification from the host device 220 and determining the write shaping state of the host device 220 based on this notification, by determining whether the host device 220 supports write operations via a memory-based cache. If the host device 220 does not support write operations via a memory-based cache, the SLC cache 304 is allocated to write data to the memory system 200.

[0043] In some embodiments, the notification includes at least one of the following: an Identification Controller (IDC) command received during device discovery, a Group Found Feature (GSF) notification, a write pressure bandwidth requirement, a write shaping notification, or a shaping size notification. The IDC command, GSF feature, and write shaping notification may indicate whether the host device 220 supports write shaping, i.e., whether the host device 220 stores write data up to a predetermined size via a memory-based cache before sending the write request 312. In some embodiments, the predetermined size is indicated by the shaping size notification, for example, 10 MB per stream. The write pressure bandwidth requirement indicates the bandwidth requirement for bursty or sustained write pressure, which further indicates whether the write data from the host device 220 to the memory system 200 is large enough to complete a full write cycle of the XLC memory block.

[0044] In some embodiments, the memory system 200, for example, by the memory controller 202, dynamically detects the use case of the host device 220 and autonomously configures the SLC cache 304 for data writing accordingly. In some examples, in a bursty small-block write environment, the SLC cache 304 is enabled and configured to a small size (e.g., less than 1 MB). In some examples, in a multi-tenant large-block write environment, the SLC cache 304 is enabled and configured to a large size (e.g., greater than 1 MB but less than 10 MB). In some examples, the SLC cache 304 is instantly adjusted to increase or decrease its size. In some examples, in a very large block (e.g., greater than 10 MB) or sequential write environment, the SLC cache 304 is disabled.

[0045] In some embodiments, the memory system 200 receives at least one write command or write request 312 from the host device 220 for writing host data and detects an input / output (I / O) pattern based on at least one write command. The memory system 200 then determines the write shaping state of the host device 220 by, for example, a memory controller 202 determining whether the I / O pattern indicates a sequential data area or a random data area relative to the logical block addressing (LBA). If the I / O pattern indicates a random data area relative to the LBA, the SLC cache 304 is allocated and activated to write data to the memory system 200. If the I / O pattern indicates a sequential data area relative to the LBA, the SLC cache 304 is not allocated or activated to write data to the memory system 200.

[0046] In some embodiments, the memory system 200 receives host data from the host device 220 in response to one or more write requests 312. After the SLC cache 304 is allocated, the memory system 200 stores the host data in the memory system 200 by writing the host data to multiple memory blocks in the SLC cache 304, and moving the data from the SLC cache 304 to one or more memory blocks in the XLC main memory unit 310 when the SLC cache 304 is full or reaches a predetermined amount of data to be stored. In some embodiments, each of the multiple memory blocks in the SLC cache 304 is located on a different die of the memory system 200.

[0047] On the one hand, the SLC cache 304 simplifies integration and maximizes the efficiency of the XLC (e.g., PLC) memory system 200. On the other hand, the SLC cache 304 steals capacity from the XLC (e.g., PLC) memory system 200, affecting the durability and performance of the memory system 200. Thus, in various environments, it is preferable to dynamically control the size of the SLC cache 304.

[0048] In some embodiments, the memory system 200 continuously monitors write environment information for writing data to the memory system 200, for example by a memory controller 202, and dynamically adjusts the size of the SLC cache 304 based on the write environment information. In some embodiments, the write environment information includes at least one of the following: information related to IDC commands received during device discovery, write workload detected from the host device 220, write pressure bandwidth requirements, or shaping size notifications. In some embodiments, the write environment information is monitored based on a machine learning model or an artificial intelligence (AI) model.

[0049] In some embodiments, after monitoring the write workload from the host device 220, the memory system 200 dynamically adjusts the size of the SLC cache 304 based on the write workload, for example, by a memory controller 202. For example, the size of the SLC cache 304 increases as the write workload increases, and decreases as the write workload decreases.

[0050] In some embodiments, after monitoring the degree of data bursting from the host device 220, the memory system 200 dynamically adjusts the size of the SLC cache 304 based on the degree of data bursting, for example, by a memory controller 202. For example, the size of the SLC cache 304 increases as the degree of data bursting decreases, and decreases as the degree of data bursting increases.

[0051] In some embodiments, after monitoring the degree of write pressure from the host device 220, the memory system 200 dynamically adjusts the size of the SLC cache 304 based on the degree of write pressure, for example, by the memory controller 202. In some examples, if the degree of write pressure is high and below a predetermined threshold, the size of the SLC cache 304 increases. In some examples, if the degree of write pressure is low and below a predetermined threshold, the size of the SLC cache 304 decreases. In some examples, if the degree of write pressure is greater than a predetermined threshold, the SLC cache 304 is disabled, and data from the host device 220 is written directly to multiple XLC memory blocks in the XLC main memory unit 310 (without going through the SLC cache 304).

[0052] In some embodiments, the SLC cache 304 is initialized with a default size smaller than a predetermined threshold, and in the default mode, data is written to multiple XLC memory blocks in the XLC main memory section 310 via the SLC cache 304 in the memory system 200.

[0053] In some embodiments, the SLC cache 304 is configured as a dynamic cache that is enabled or disabled with a dynamic size based on the write shaping state and / or write environment, so that a single version of the firmware in the memory system 200 can adapt to any use case for writing data to the memory system 200.

[0054] Figure 4 is a block diagram of an exemplary memory system 400, including an SLC cache, that supports multiple bits per cell, according to some embodiments of this teaching. In some embodiments, the memory system 400 is a non-volatile NAND memory device configured to store instructions and data over long periods of time, and may be implemented as the memory system 200 in Figure 2 or 3. As shown in Figure 4, the memory system 400 includes a plurality of erase blocks (EBs) 431, 441. In some embodiments, each of the plurality of EBs in the memory system 400 corresponds to a memory block 302 in the memory system 200. In some embodiments, a subset of the plurality of EBs (e.g., three EBs) corresponds to a memory block 302. In some embodiments, a subset of the plurality of EBs in the memory system 400 corresponds to two memory blocks 302, for example, three EBs correspond to three decks of pairs of two memory blocks 302. Each EB includes a set of memory pages 210 that are erased jointly, independently of any other set of memory pages associated with any other EB. In the example shown in Figure 4, the memory system 400 is divided vertically into multiple dies 411, 412, and 413, and horizontally into multiple bands 421, 422, and 423.

[0055] Each of the multiple bands 421, 422, and 423 contains multiple EBs having the same capacity utilization level. In some examples, the memory system 400 is a PLC-based memory. Thus, the memory system 400 includes an SLC band 421, one or more PLC bands 422, and one or more unallocated bands 423. In this example, the SLC band 421 is formed by a set of EBs 430 distributed across different dies 411, 412, and 413. In some embodiments, the memory system 400 can only write one EB per die at a time. By distributing the EBs in the SLC band 421 across different dies in this way, the writing process can be accelerated by writing data to the SLC EBs in the SLC band 421 in parallel. In this example, the SLC band 421 uses 20% of the available capacity in each EB within the SLC band 421. In some embodiments, the SLC band 421 contains only one EB, or a subset of the set of EBs 430.

[0056] As shown in Figure 4, each PLC band 422, for example PLC band 440, is formed by a set of EBs distributed across different dies 411, 412, and 413. In this example, each PLC band 422 uses all of the available capacity in each EB within the PLC band.

[0057] As shown in Figure 4, each unassigned band 423, for example, unassigned band 450, is formed by a set of EBs distributed across different dies 411, 412, and 413. In this example, each unassigned band 423 is waiting to be assigned as either an SLC band or a PLC band.

[0058] In some embodiments, when the SLC band 421 is enabled and involved in data writing (for example, based on the write shaping state of the host device), the memory system 400 stores host data from the host device by writing host data to the EBs in the SLC band 421 and moving the data from the SLC band 421 to one or more EBs in the PLC band when the SLC band 421 is full or reaches a predetermined amount of data to store. For example, the memory system 400 stores host data in the SLC band 421 with one bit per cell, starting from EB 431 and progressing to other EBs in the SLC band 421. As an example, when the SLC band 421 is full of data or reaches a predetermined amount of data to store (e.g., 10 MB, or a size sufficient to complete a write cycle), the memory system 400 moves the data in the SLC band 421 to the PLC EB 441 with 5 bits per cell. In this way, the SLC band 421 functions as a memory cache during data writing in the memory system 400.

[0059] In some embodiments, if the SLC band 421 is disabled or not involved in data writing (for example, based on the write shaping state of the host device), the memory system 400 converts the SLC EBs in the SLC band 421 to PLC EBs and utilizes the full capacity of each set of EBs 430. In some embodiments, if an SLC band is needed again in the memory system 400, a new SLC band may be created again within the SLC band 421 or in a different area of ​​the memory system 400. In some embodiments, when the memory system 400 dynamically enables or disables SLC write-through for data writing, the PLC band 422 is rotated to function as an SLC band in the memory system 400.

[0060] In some embodiments, the memory system 400 may include any number of SLC bands 421. Similarly, the memory system 400 may include any number of PLC bands 422 and unallocated bands 423. In some embodiments, the number of SLC bands 421 in the memory system 400 is dynamically changed based on the write workload or write pressure detected from the host device coupled to the memory system 400. In some embodiments, the number of SLC EBs in the SLC band 421 is dynamically changed based on the write workload or write pressure detected from the host device coupled to the memory system 400.

[0061] In some embodiments, the memory system 400 includes two SLC bands. In this case, when one full SLC band is destaged to the PLC block, the other SLC band can absorb new write data from the host device. In some embodiments, the size of each SLC band matches the size required to complete a full multipath programming algorithm or a full write cycle on the PLC block.

[0062] In some embodiments, the memory system 400 includes a single SLC band containing 2 × M EBs. In this case, when M SLC EBs in a single SLC band are destaged to the PLC block, the other M SLC EBs in the SLC band can absorb new write data from the host device.

[0063] In some embodiments, under heavy and sustained write pressure from the host device, more SLC bands are allocated by the memory system 400 to absorb that pressure, resulting in a reduction in PLC storage capacity. In some embodiments, under bursty write pressure from the host device, fewer SLC bands are allocated by the memory system 400, and storage capacity is returned from the SLC to the PLC.

[0064] In some embodiments, the memory system 400 includes one or any number of SLC bands. In the example shown in Figure 4, the memory system 400 includes one SLC band 421 containing multiple EBs. In some embodiments, the number of EBs in each SLC band can be set based on notifications from the host device, such as notifications of NVMe acquisition / configuration features or host bandwidth requirements. In some embodiments, each EB in the SLC band 421 has tens of MBs, and each EB in the PLC band (e.g., PLC band 440) has hundreds of MBs.

[0065] As shown in Figure 4, each band (SLC, PLC, or unassigned) contains 1 EB per die. In some embodiments, the number of dies 411, 412, and 413 can be set from 1 to 100. In some embodiments, the band performance of the memory system 400 varies proportionally to the number of dies / EB. In some embodiments, the memory system 400 monitors the workload from the host device using a machine learning model or AI model and tunes the configuration of the SLC band 421 according to this workload.

[0066] In some embodiments, the memory system 400 automatically allocates a small SLC cache during initialization. That is, when the memory system 400 is initialized, the size of the SLC band 421 is small. In some embodiments, all host writes default to going through the SLC cache (e.g., SLC band 421). The memory system 400 continuously monitors the write workload from the host device. If the host device provides a write data flow large enough to perform PLC programming, the SLC cache is disabled and programming is performed directly from the host memory to the PLC EB in the PLC band of the memory system 400. If the write pressure from the host device is high but insufficient to perform full PLC programming, the size of the SLC cache is increased to provide more bandwidth.

[0067] Figure 5 is a flowchart of an exemplary method 500 for dynamically enabling or disabling an SLC cache in a memory device based on the write shaping state of a host device, according to some embodiments of this teaching. In some embodiments, method 500 is performed by a memory device implemented as one of the memory systems 200, 400 in Figures 2-4. In some embodiments, the memory device stores data in XLC memory blocks at x bits per cell (where x is greater than 1). In some embodiments, the memory device dynamically generates and / or enables an SLC cache for caching the write data of the XLC memory blocks during data writing.

[0068] In operation 510, the memory device checks whether it has received a notification from the host device coupled to it regarding host-based write shaping on the host device. In some embodiments, this notification is an IDC command or GSF notification indicating whether the host device supports write shaping, for example, whether it stores write data up to a predetermined size before sending it to the memory device for writing. In some embodiments, operation 510 occurs during the device discovery process or initialization process of the memory device.

[0069] In some cases, upon determining (in operation 522) that it has received a notification from the host device regarding host-based write shaping, the memory device further determines in operation 524 whether the host device will shape the write or perform write shaping based on this notification. Upon determining (in operation 542) that the host device will perform write shaping, the memory device disables the SLC cache within the memory device in operation 546. In some embodiments, after operation 546, the memory blocks in the SLC cache are released to function as XLC memory blocks for data writing, in which case the write data from the host device is written directly to the XLC memory blocks of the memory device without passing through any SLC cache. Upon determining (in operation 552) that the host device will not shape the write, the memory device enables the SLC cache within the memory device in operation 556, in which case the write data from the host device is stored in the SLC cache before being destaged to the XLC memory blocks of the memory device.

[0070] Conversely, in some cases, if the memory device determines (in operation 532) that it has not received any notification from the host device regarding host-based write shaping, it further analyzes the write input / output (I / O) pattern from the host device in operation 534. Then, in operation 536, the memory device determines whether the write I / O pattern from the host device represents a sequential data stream or a random data stream, for example, a logical block addressing (LBA). If the memory device determines (in operation 544) that the write I / O pattern represents a sequential data stream, it disables the SLC cache within the memory device in operation 546. In some embodiments, after operation 546, the memory block in the SLC cache is released to function as an XLC memory block for data writing, in which case the write data from the host device is written directly to the XLC memory block of the memory device without passing through any SLC cache. In response to the determination (in operation 554) that the write I / O pattern represents a random data stream, the memory device enables the SLC cache within the memory device in operation 556, in which case the write data from the host device is stored in the SLC cache before being destaged in the memory device's XLC memory block.

[0071] Figure 6 is a flowchart of an exemplary method 600 for dynamically adjusting the size of an SLC cache in a memory device based on the write shaping state of a host device, according to some embodiments of this teaching. In some embodiments, method 600 is performed by a memory device implemented as one of the memory systems 200, 400 in Figures 2-4. In some embodiments, the memory device stores data in XLC memory blocks at x bits per cell (where x is greater than 1). In some embodiments, the memory device dynamically adjusts the size of an SLC cache for caching the write data of the XLC memory blocks during data writing.

[0072] In operation 610, the memory device checks whether it has received a notification from the host device coupled to it regarding information about the memory device's write environment. In some embodiments, this notification is an IDC command, a write workload notification, or a write pressure notification. In some embodiments, this notification indicates the expected write workload or write pressure in a future data write process from the host device to the memory device. In some embodiments, this notification indicates the type of client environment that presents the type of potential write pressure. For example, a host device serving in a PC environment would indicate bursty write pressure, while a host device serving in a data center environment would indicate sustained write pressure. In some embodiments, operation 610 occurs during the memory device's device discovery or initialization process.

[0073] In some cases, upon determining (in operation 622) that it has received notification from the host device regarding write environment information, the memory device adjusts the size of the SLC cache in operation 624 based on the write environment information. The thus resized SLC cache is used to store the write data from the host device before destaging the write data from the SLC cache to the XLC memory block of the memory device. Method 600 then proceeds to operation 630, in which the memory device processes the write request from the host device.

[0074] Conversely, in some cases, if it is determined (in operation 626) that no notification regarding write environment information has been received from the host device, the above method proceeds directly to operation 630 without changing the size of the SLC cache and processes the write request from the host device.

[0075] In operation 640, the memory device monitors the write pressure (or write workload) from the host device. In operation 650, the memory device checks whether the write pressure (or write workload) indicates bursty or sustained write data.

[0076] In response to the determination (in operation 662) that the data to be written is bursty (for example, if the degree of data burstiness increases or exceeds a predetermined threshold), the memory device, in operation 664, reduces the size of the SLC cache within the memory device by an amount or percentage determined, for example, based on the degree of data burstiness. Method 600 then returns to operation 630 and continues processing the write request from the host device.

[0077] Conversely, in response to the determination (in operation 672) that the write data is persistent (for example, if the degree of data burstiness decreases or falls below a predetermined threshold), the memory device increases the size of the SLC cache within the memory device in operation 674 by an amount or percentage determined, for example, based on the degree of data burstiness. Method 600 then returns to operation 630 and continues processing the write request from the host device.

[0078] In some embodiments, each threshold or adjustment in this teaching can be determined based on the machine learning model, AI model, and / or the historical data write performance of the memory device.

[0079] Memory is also used to store instructions and data associated with methods 500, 600, and includes high-speed random-access memory such as DRAM, SRAM, DDR RAM, or other random-access solid-state memory devices, and optionally includes non-volatile memory such as one or more magnetic disk storage devices, one or more optical disk storage devices, one or more flash memory devices, or one or more other non-volatile solid-state storage devices. Memory optionally includes one or more storage devices located remotely from one or more processing units. Memory, or alternatively non-volatile memory within memory, includes non-transient computer-readable storage media. In some embodiments, memory, or the non-transient computer-readable storage media of memory, stores programs, modules, and data structures, or subsets or supersets, for carrying out methods 500, 600. Alternatively, in some embodiments, an electronic device carries out methods 500, 600, at least in part, based on an ASIC. The memory system of an electronic device includes an SSD in a data center or client device.

[0080] Each of the elements identified above may be stored in one or more of the memory devices described above and corresponds to a set of instructions for performing the functions described above. Since the modules or programs (i.e., sets of instructions) identified above do not need to be implemented as separate software programs, procedures, modules, or data structures, various subsets of these modules may be combined or rearranged in various embodiments. In some embodiments, memory optionally stores a subset of the modules and data structures identified above. Furthermore, memory optionally stores additional modules and data structures not described above.

[0081] The terms used in the descriptions of the various implementations described herein are intended solely to describe, and not to limit, a particular implementation. When used in the descriptions of the various implementations and the accompanying claims, the singular forms "a," "an," and "the" are intended to include the plural form unless the context clearly indicates otherwise. As used herein, the terms "and / or" refer to, and are understood to encompass, any and all possible combinations of one or more of the enumerated items. Where used herein, the terms "includes," "comprises," and / or "comprising" indicate the presence of a described feature, integer, step, operation, element, and / or component, but are not understood to exclude the presence or addition of one or more other features, integers, steps, operations, elements, components, and / or groups thereof. In addition, while terms such as "first," "second," etc., may be used herein to describe various elements, it should be understood that these elements are not limited by these terms. These terms are used solely to distinguish one element from another.

[0082] As used herein, the term "if" is to be interpreted, depending on the context, as to mean "when," "upon," "in response to a determination," "in response to detection," or "in accordance with a determination that." Similarly, the phrase "when it is determined that" or "when the 'statement condition or event' is detected" is to be interpreted, depending on the context, as to mean "when it is determined that," "in response to a determination," "when the 'statement condition or event' is detected," "in response to the detection of the 'statement condition or event'," or "in accordance with a determination that the 'statement condition or event' has been detected."

[0083] The above explanation, intended for interpretation, was given with reference to specific embodiments. However, the above explanatory consideration is not intended to be exhaustive or to limit the claims to the precise form disclosed. In light of the above teachings, many modifications and variations are possible. The embodiments have been selected and described in order to best interpret the principles of operation and practical applications, and thereby be understandable to those skilled in the art.

[0084] While various drawings illustrate numerous logical stages in a specific order, stages that are not order-dependent may be rearranged, and other stages may be combined or divided. Although some rearrangements or other groupings have been specifically described, other rearrangements or groupings will be obvious to those skilled in the art. Therefore, the orderings and groupings presented herein are not an exhaustive list of alternatives. Furthermore, it should be recognized that the above stages can be implemented in hardware, firmware, software, or any combination thereof.

Claims

1. A method implemented in an electronic device including a host device and a memory device, A step of identifying the write shaping state of the host device, wherein the memory device is coupled to the host device and includes a plurality of x-level cell (XLC) memory blocks (where x is greater than 1), The steps include determining, based on the write shaping state, that the host device will perform a write operation without a memory-based cache, In response to a determination that the host device will perform a write operation without the memory-based cache, the steps include allocating a y-level cell (YLC) cache (where y is less than x) within the memory device and making it function as the memory-based cache, The steps of storing data in the plurality of XLC memory blocks via the YLC cache in the memory device in response to one or more write requests. Methods that include...

2. The step of identifying the write shaping state is: The steps include: receiving a notification from the host device using the memory device; A step of determining the write shaping state of the host device by determining whether the host device supports write operations via the memory-based cache based on the notification, wherein if the host device does not support write operations via the memory-based cache, the YLC cache is allocated to write data to the memory device, and The method according to claim 1, including the method described in claim 1.

3. The aforementioned notice is, Identification Controller (IDC) commands received during device discovery, Acquired / Setting Features (GSF) Notification, Write pressure bandwidth requirements, Write shaping notification, or Shaping size notification The method according to claim 2, comprising at least one of the following.

4. The step of identifying the write shaping state is: The memory device receives at least one write command from the host device for writing host data; The steps include detecting an input / output (I / O) pattern based on at least one write command, A step of determining the write shaping state of the host device by determining whether the I / O pattern indicates a sequential data area or a random data area with respect to logical block addressing (LBA), wherein if the I / O pattern indicates a random data area with respect to LBA, the YLC cache is allocated to write data to the memory device. The method according to any one of claims 1 to 3, including

5. The step of storing data in the aforementioned plurality of XLC memory blocks is: The steps include receiving host data from the host device in response to one or more write requests, A step of writing the host data to a plurality of memory blocks in the YLC cache, wherein each of the plurality of memory blocks is located on a different die of the memory device, and If the YLC cache is full or has enough data to complete an XLC program cycle, the step is to move the data from the YLC cache to one of the multiple XLC memory blocks. The steps include storing the host data in the memory device and The method according to any one of claims 1 to 4, including the method described in any one of claims 1 to 4.

6. The steps include monitoring write environment information for writing data to the memory device, A step of dynamically adjusting the size of the YLC cache based on the aforementioned writing environment information. The method according to any one of claims 1 to 5, further comprising:

7. The aforementioned writing environment information is: Information regarding Identification Controller (IDC) commands received during device discovery. The write workload detected from the host device, Write pressure bandwidth requirements, or Shaping size notification The method according to claim 6, comprising at least one of the following.

8. The steps include monitoring the write workload from the host device, A step of dynamically adjusting the size of the YLC cache based on the write workload, As the write workload increases, the size of the YLC cache increases. As the write workload decreases, the size of the YLC cache decreases. Steps and The method according to claim 6 or 7, further comprising:

9. The steps include monitoring the degree of data burstiness from the host device, A step of dynamically adjusting the size of the YLC cache based on the degree of data burstiness, As the degree of data burstiness decreases, the size of the YLC cache increases. As the degree of data bursting increases, the size of the YLC cache decreases. Steps and The method according to any one of claims 6 to 8, further comprising:

10. The steps include monitoring the degree of write pressure from the host device, A step of dynamically adjusting the size of the YLC cache based on the degree of the write pressure, When the degree of the write pressure increases and is less than a predetermined threshold, the size of the YLC cache increases. When the degree of the write pressure decreases and is less than the predetermined threshold, the size of the YLC cache decreases. If the write pressure is greater than the predetermined threshold, the YLC cache is disabled and data from the host device is written directly to the multiple XLC memory blocks. Steps and The method according to any one of claims 6 to 9, further comprising:

11. The method according to any one of claims 6 to 10, wherein the writing environment information is monitored based on a machine learning model or an artificial intelligence (AI) model.

12. A step of initializing the YLC cache with a default size smaller than a predetermined threshold, As the default mode, the steps include writing data to the plurality of XLC memory blocks via the YLC cache in the memory device and The method according to any one of claims 1 to 11, further comprising:

13. The step of identifying the write shaping state is: The steps include receiving a notification from the host device, A step of determining the write shaping state of the host device by determining whether the host device supports write operations via the memory-based cache based on the notification, wherein if the host device does not support write operations via the memory-based cache, the YLC cache is allocated to write data to the memory device, and The method according to any one of claims 1 to 12, including the method described in any one of claims 1 to 12.

14. The method according to claim 13, further comprising the step of writing data directly from the host device to the plurality of XLC memory blocks without going through the YLC cache, in response to a determination that the host device performs a write operation via the memory-based cache.

15. The host device and A memory device coupled to the host device and configured to perform the method described in any one of claims 1 to 14: Electronic systems, including

16. Multiple x-level cell (XLC) memory blocks (where x is greater than 1), A y-level cell (YLC) cache (where y is less than x), A memory controller capable of executing an instruction, wherein when the instruction is executed, the memory controller is instructed to perform the method according to any one of claims 1 to 14. A memory device that includes this.