Separating parity data from host data in the memory subsystem

By separating parity data and host data in the memory subsystem, the problems of low read performance and long initialization time in the prior art are solved, and more efficient data protection and performance improvement are achieved.

CN112988450BActive Publication Date: 2024-11-22MICRON TECHNOLOGY INC
View PDF 0 Cites 0 Cited by

Patent Information

Application Number
CN202011494203.2
Authority / Receiving Office
CN · China
Patent Type
Patents(China)
Current Assignee / Owner
Priority Date
2019-12-17
Filing Date
2020-12-17
Publication Date
2024-11-22
Estimated Expiration
2040-12-17

AI Technical Summary

Technical Problem

In the existing memory subsystem, parity data is stored together with host data, resulting in a degradation in reading performance, unable to fully utilize the potential of memory, and a long initialization time.

Method used

In the memory subsystem, parity data is stored separately from the host data, and specially stored by accumulating parity data on volatile memory and storing it in another unit when a specific size condition is met. Host data and parity data improve parallel programming capabilities.

Benefits of technology

Improves the read performance and initialization time of the memory subsystem, ensures that the host data is read simultaneously in a separate unit, avoids idle time, and enhances data protection capabilities.

✦ Generated by Eureka AI based on patent content.

Smart Images

  • Figure CN112988450B_ABST
    Figure CN112988450B_ABST
Patent Text Reader

Abstract

The present application relates to separating parity data from host data in a memory subsystem. A plurality of write operations are performed to write a set of host data on a first unit of the memory subsystem. A set of parity data is generated based on the host data. It is determined whether the set of parity data satisfies a size condition. If it is determined that the set of parity data satisfies the size condition, the set of parity data is stored on a second unit of the memory subsystem.
Need to check novelty before this filing date? Find Prior Art

Description

Technical Field

[0001] Embodiments of the present disclosure relate generally to memory subsystems, and more particularly, to separating parity data from host data in a memory subsystem. Background Art

[0002] The memory subsystem may include one or more memory devices that store data. For example, the memory devices may be non-volatile memory devices and volatile memory devices. Typically, the host system may utilize the memory subsystem to store data at the memory devices and retrieve data from the memory devices. Summary of the invention

[0003] In one aspect, the present disclosure provides a system comprising: a memory device; a volatile memory; and a processing device operably coupled to the memory device and the volatile memory to: append parity data to a set of parity data on the volatile memory, the parity data being based on a set of host data on a page stripe of a first unit of the memory device; determine whether the set of parity data satisfies a size condition; in response to determining that the set of parity data does not satisfy the size condition, continue to append additional parity data to the set of parity data, the additional parity data being based on one or more sets of corresponding host data on one or more corresponding additional page stripes; and in response to determining that the set of parity data satisfies the size condition, store the set of parity data in a second unit of the memory device.

[0004] On the other hand, the present disclosure provides a method, which includes: performing multiple write operations to write a set of host data on a first unit of a memory subsystem; generating a set of parity data based on the host data; determining whether the set of parity data satisfies a size condition; and in response to determining that the set of parity data satisfies the size condition, storing, by a processing device, the set of parity data on a second unit of the memory subsystem.

[0005] On the other hand, the present disclosure provides a non-transitory computer-readable storage medium, comprising instructions that, when executed by a processing device, cause the processing device to: append parity data to a set of parity data on a volatile memory, the parity data being based on a set of host data on a page stripe of a first unit of a memory device; determine whether the set of parity data satisfies a size condition; in response to determining that the set of parity data does not satisfy the size condition, continue to append additional parity data to the set of parity data, the additional parity data being based on one or more sets of corresponding host data on one or more corresponding additional page stripes; and in response to determining that the set of parity data satisfies the size condition, store the set of parity data in a second unit of the memory device. BRIEF DESCRIPTION OF THE DRAWINGS

[0006] The present disclosure will be more fully understood from the detailed description given below and the accompanying drawings of various embodiments of the present disclosure. However, the accompanying drawings should not be considered to limit the present invention to specific embodiments, but are only for explanation and understanding.

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

[0008] Figure 2 is an example of separating host data and parity data in different memory subsystem units according to some embodiments of the present disclosure.

[0009] Figure 3 is an example of the relationship between separate host data and parity data in different memory subsystem units according to some embodiments of the present disclosure.

[0010] Figure 4 is a flow chart of an example method of storing parity data in a volatile memory until a size condition is met before separating the parity data and host data in different cells of a memory device according to some embodiments of the present disclosure.

[0011] Figure 5 is a flow chart of an example method of separating parity data from host data in a memory subsystem according to some embodiments of the present disclosure.

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

[0013] Various aspects of the present disclosure are directed to separating parity data from host data in a memory subsystem. The memory subsystem may be a storage device, a memory module, or a mixture of a storage device and a memory module. Figure 1 Examples of storage devices and memory modules are described. In general, a host system may utilize a memory subsystem that includes one or more memory components, such as a memory device that stores data. The host system may provide data to be stored at the memory subsystem and may request data to be retrieved from the memory subsystem.

[0014] Data operations may be performed by the memory subsystem. Data operations may be operations initiated by the host. For example, the host system may initiate data operations (e.g., write, read, erase, etc.) on the memory subsystem. The host system may send access requests (e.g., write commands, read commands) to the memory subsystem, for example, to store data on a memory device at the memory subsystem and read data from a memory device on the memory subsystem.

[0015] The data to be read or written specified by a host request is hereinafter referred to as “host data.” The host request may include logical address information (eg, logical block address (LBA), namespace) for the host data, which is a location that the host system associates with the host data.

[0016] When host data is stored on the memory subsystem, the memory subsystem may implement a redundancy mechanism to protect the host data from a failure of a portion of the memory device storing the host data. For example, for a NAND type flash memory device, the memory subsystem may implement a redundant array of independent NAND (RAIN) operation to provide redundancy for the data stored on the memory subsystem. For example, when data received from the host system is written to the memory subsystem, the memory subsystem may generate parity data. The memory subsystem may generate parity data based on an exclusive OR (XOR) operation with the received host data, and use the parity data to reconstruct or recalculate the host data in the event that a portion of the memory device storing data from the host system fails. For example, the memory subsystem may calculate parity data for a specific number of host data locations of a unit (e.g., a data block) of the memory subsystem. Parity data may be generated based on an XOR operation between each host data stored on a specific number of host data locations. If a portion of a memory device storing one of the host data fails and the corresponding data is lost or damaged, the memory subsystem can reconstruct the lost / damaged data based on an XOR operation between the remaining host data and the parity data.

[0017] Conventionally, parity data is stored in the same unit of the memory subsystem together with host data. For example, host data is stored on page stripes of a data block, and parity data based on host data is stored on page stripes of the same data block. Striping may refer to the process of dividing a memory device into smaller segments that span available portions (e.g., channels, dies, and planes) of a memory device. Typically, each stripe is horizontally spread across all channels, dies, and planes available in a memory device. In an example, page stripes are generally used one after another in a sequential manner. Each unit in a page stripe is a portion of a fixed size (e.g., 16KB, etc.) that holds data. Multiple fixed-size portions of a page stripe. Striping is intended to allow parallelism (e.g., performing independent data accesses in parallel) during read, write, and erase operations. If the entire body of data is stored on a specific portion of a failed memory device, spreading the data into stripes in different portions of the memory device also helps to avoid losing the entire body of data. Therefore, a page stripe may refer to a group of a specific number of data locations scattered on multiple parts of a memory device designed to store segments of a data body. In an example within a conventional system, each segment of host data is stored in each data position of a given page stripe of a given data block until the end of the page stripe is detected. When the end of the stripe is detected, parity data calculated based on an XOR operation between host data stored in the data position of a given page stripe is stored in the last position of a given page stripe on a given data block. Therefore, each data block contains multiple page stripes, wherein each page stripe stores parity data and host data. However, storing parity data together with host data on a page stripe on a data block reduces read performance. For example, in the case of a sequential host data read operation, the memory subsystem does not read data from the page stripe position storing parity data because the position does not contain any host data. Therefore, the position storing parity data remains idle, while the memory subsystem simultaneously performs a read operation on the remaining data positions of the stripe containing host data. Due to the idle time, the memory subsystem cannot achieve its maximum potential for read performance (e.g., reading host data from every available location on the page stripe) because during the time when host data is simultaneously being read from page stripe locations, the memory subsystem reads from at least one less data location than the total available data locations on the page stripe.

[0018] Aspects of the present disclosure address the above and other deficiencies by having a memory subsystem that stores host data and corresponding parity data in separate units of the memory subsystem. During a host data write operation, the memory subsystem may write the host data to each available position of a page stripe of a unit (e.g., a data block) of the memory subsystem. The memory subsystem may generate corresponding parity data based on an XOR operation performed between each of the host data on the page stripe. The memory subsystem may store parity data on a volatile memory of the memory subsystem instead of storing parity data on the same page stripe of the same unit of the memory subsystem. The memory subsystem may continue to write additional host data to available positions of additional page stripes of the same unit of the memory subsystem. The memory subsystem may accumulate a set of parity data generated based on the host data stored on the page stripe on the volatile memory. The memory subsystem may monitor the set of parity data and determine whether the set of parity data on the volatile memory satisfies a specified size condition. For example, the memory subsystem may identify whether the set of parity data is equivalent to the data of the entire page stripe. If the size condition is met, the memory subsystem may store the set of parity data from the volatile memory to another page stripe of another unit of the memory subsystem, thereby separating the host data and the corresponding parity data in different units of the memory subsystem. In this way, the memory subsystem may dedicate one unit to exclusively store the host data and a separate unit to exclusively store the parity data. By accumulating the parity data equivalent to the entire page stripe in the volatile memory, the memory subsystem may issue a parallel programming command to write the data of the entire page stripe at once to improve performance, rather than switching between writing the host data in one unit (e.g., a block) and writing each individual parity data in another unit (e.g., another block) when calculating individual parity data. In the event of a read failure from a portion of the memory subsystem storing the host data, the memory subsystem may reconstruct the host data using the set of parity data stored on the unit dedicated to storing the parity data.

[0019] Advantages of the present disclosure include, but are not limited to, increased performance of the memory subsystem due to improved read performance and memory device initialization associated with the memory subsystem, while maintaining the ability to provide data protection using redundant operations. As a result of storing parity data separately from host data, the memory subsystem can store host data exclusively on a specific cell of the memory subsystem, which allows the memory subsystem to simultaneously read from each data location of the page stripe of the cell without incurring any idle time associated with any data location. The elimination of idle time allows the memory subsystem to achieve the maximum possible sequential read performance. In addition, the memory subsystem can maintain a list of relationships between data locations storing host data and parity data in separate cells (e.g., separate blocks). Therefore, at device initialization, the memory subsystem can use the list to identify data locations containing host data, thereby eliminating the need to scan all data locations available on the device to identify which locations contain host data. Therefore, device initialization time can be improved and valuable computing resources are not wasted on unnecessarily scanning all data locations.

[0020] Figure 1 An example computing system 100 is shown that includes a memory subsystem 110 according to some embodiments of the present disclosure. Memory subsystem 110 may include media such as one or more volatile memory devices (e.g., memory device 140), one or more non-volatile memory devices (e.g., memory device 130), or a combination thereof.

[0021] The memory subsystem 110 may be a storage device, a memory module, or a mixture of storage devices and memory modules. Examples of storage devices include solid-state drives (SSDs), flash drives, universal serial bus (USB) flash drives, embedded multimedia controllers (eMMC) drives, universal flash storage (UFS) drives, secure digital (SD) cards, and hard disk drives (HDDs). Examples of memory modules include dual in-line memory modules (DIMMs), small outline DIMMs (SO-DIMMs), and various types of non-volatile dual in-line memory modules (NVDIMMs).

[0022] The computing system 100 may be a computing device such as a desktop computer, a laptop computer, a network server, a mobile device, a vehicle (e.g., an airplane, a drone, a train, a car, or other transportation), an Internet of Things (IoT) enabled device, an embedded computer (e.g., a computer included in a vehicle, an industrial device, or a networked business device), or such a computing device including a memory and a processing device.

[0023] The computing system 100 may include a host system 120 coupled to one or more memory subsystems 110. In some embodiments, the host system 120 is coupled to memory subsystems 110 of different types. Figure 1 An example of a host system 120 coupled to a memory subsystem 110 is shown. As used herein, "coupled to" or "coupled with..." generally refers to a connection between components, which can be an indirect communication connection or a direct communication connection (e.g., without intervening components), whether wired or wireless, including connection methods such as electrical, optical, magnetic, etc.

[0024] The host system 120 may include a processor chipset and a software stack executed by the processor chipset. The processor chipset may include one or more cores, one or more caches, a memory controller (e.g., an NVDIMM controller), and a storage protocol controller (e.g., a PCIe controller, a SATA controller). For example, the host system 120 uses the memory subsystem 110 to write data to the memory subsystem 110 and read data from the memory subsystem 110.

[0025] The host system 120 may be coupled to the memory subsystem 110 via a physical host interface. Examples of the physical host interface include, but are not limited to, a serial advanced technology attachment (SATA) interface, a peripheral component interconnect (PCIe) interface, a universal serial bus (USB) interface, a fiber channel, a serial attached SCSI (SAS), a double data rate (DDR) memory bus, a small computer system interface (SCSI), a dual in-line memory module (DIMM) interface (e.g., a DIMM slot interface supporting double data rate (DDR)), etc. The physical host interface may be used to transfer data between the host system 120 and the memory subsystem 110. When the memory subsystem 110 is coupled to the host system 120 through a PCIe interface, the host system 120 may also utilize an NVM Express (NVMe) interface to access components (e.g., the memory device 130). The physical host interface may provide an interface for passing control, address, data, and other signals between the memory subsystem 110 and the host system 120. Figure 1 Memory subsystem 110 is shown as an example. In general, host system 120 can access multiple memory subsystems via the same communication connection, multiple separate communication connections, and / or a combination of communication connections.

[0026] The memory devices 130, 140 may include any combination of different types of non-volatile memory devices and / or volatile memory devices. Volatile memory devices (e.g., memory device 140) may be, but are not limited to, random access memory (RAM), such as dynamic random access memory (DRAM) and synchronous dynamic random access memory (SDRAM).

[0027] Examples of non-volatile memory devices (e.g., memory device 130) include NAND-type flash memory and write-in-place memory, such as three-dimensional cross-point ("3D cross-point") memory. A cross-point array of non-volatile memory can be combined with a stackable cross-grid data access array to perform bit storage based on changes in body resistance. In addition, compared to many flash-based memories, cross-point non-volatile memory can perform write-in-place operations, where non-volatile memory cells can be programmed without pre-erasing the non-volatile memory cells. For example, NAND-type flash memory includes two-dimensional NAND (2D NAND) and three-dimensional NAND (3D NAND).

[0028] Each of the memory devices 130 may include one or more memory cell arrays. One type of memory cell (e.g., a single-level cell (SLC)) may store one bit per cell. Other types of memory cells (e.g., a multi-level cell (MLC), a three-level cell (TLC), and a four-level cell (QLC)) may store multiple bits per cell. In some embodiments, each of the memory devices 130 may include one or more memory cell arrays, such as SLC, MLC, TLC, QLC, or any combination thereof. In some embodiments, a particular memory device may include an SLC portion, an MLC portion, a TLC portion, or a QLC portion of a memory cell. The memory cells of the memory device 130 may be grouped into pages that may refer to a logical unit of a memory device for storing data. For some types of memory (e.g., NAND), pages may be grouped to form blocks.

[0029] Although non-volatile memory components such as a 3D cross-point array of non-volatile memory cells and NAND-type flash memory (e.g., 2D NAND, 3D NAND) are described, the memory device 130 can be based on any other type of non-volatile memory, such as read-only memory (ROM), phase change memory (PCM), self-select memory, other chalcogenide-based memory, ferroelectric memory random access memory (FeTRAM), ferroelectric random access memory (FeRAM), magnetic random access memory (MRAM), spin transfer torque (STT)-MRAM, conductive bridging RAM (CBRAM), resistive random access memory (RRAM), oxide-based RRAM (OxRAM), or non-(NOR) flash memory, electrically erasable programmable read-only memory (EEPROM).

[0030] The memory subsystem controller 115 (or, for simplicity, the controller 115) can communicate with the memory device 130 to perform operations such as reading data, writing data, or erasing data at the memory device 130 and other such operations. The memory subsystem controller 115 can include hardware such as one or more integrated circuits and / or discrete components, buffer memory, or a combination thereof. The hardware can include digital circuits with dedicated (i.e., hard-coded) logic to perform the operations described herein. The memory subsystem controller 115 can be a microcontroller, a dedicated logic circuit (e.g., a field programmable gate array (FPGA), an application specific integrated circuit (ASIC), etc.), or other suitable processor.

[0031] The memory subsystem controller 115 may include a processor 117 (e.g., a processing device) configured to execute instructions stored in a local memory 119. In the illustrated example, the local memory 119 of the memory subsystem controller 115 includes an embedded memory configured to store instructions for executing various processes, operations, logic flows, and routines for controlling the operation of the memory subsystem 110, including handling communications between the memory subsystem 110 and the host system 120.

[0032] In some embodiments, local memory 119 may include memory registers for storing memory pointers, fetched data, etc. Local memory 119 may also include read-only memory (ROM) for storing microcode. Figure 1 The example memory subsystem 110 in FIG. 1 is shown as including a memory subsystem controller 115. In another embodiment of the present disclosure, the memory subsystem 110 does not include the memory subsystem controller 115, but may rely on external control (e.g., provided by an external host or by a processor or controller separate from the memory subsystem).

[0033] Typically, the memory subsystem controller 115 may receive commands or operations from the host system 120, and may convert the commands or operations into instructions or appropriate commands to achieve the desired access to the memory device 130. The memory subsystem controller 115 may be responsible for other operations, such as wear leveling operations, garbage collection operations, error detection and error correction code (ECC) operations, encryption operations, cache operations, and address conversion between logical addresses (e.g., logical block addresses (LBA), namespaces) and physical addresses (e.g., physical block addresses) associated with the memory device 130. The memory subsystem controller 115 may also include host interface circuitry to communicate with the host system 120 via a physical host interface. The host interface circuitry may convert commands received from the host system into command instructions to access the memory device 130, and convert responses associated with the memory device 130 into information for the host system 120.

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

[0035] In some embodiments, the memory device 130 includes a local media controller 135 that operates with the memory subsystem controller 115 to perform operations on one or more memory units of the memory device 130. An external controller (e.g., the memory subsystem controller 115) can manage the memory device 130 externally (e.g., perform media management operations on the memory device 130). In some embodiments, the memory device 130 is a managed memory device, which is a raw memory device combined with a local controller (e.g., the local controller 135) for media management within the same memory device package. An example of a managed memory device is a managed NAND (MNAND) device.

[0036] The memory subsystem 110 includes a parity processing component 113 that can store parity data corresponding to host data to a unit of the memory subsystem 110 that is separate from another unit storing the host data. In some embodiments, the memory subsystem controller 115 includes at least a portion of the parity processing component 113. For example, the memory subsystem controller 115 may include a processor 117 (processing device) configured to execute instructions stored in a local memory 119 to perform the operations described herein. In some embodiments, the parity processing component 113 is part of the host system 120, an application, or an operating system.

[0037] The parity processing component 113 may store parity data corresponding to host data received from the host system 120 in a unit of the memory subsystem that is separate from another unit storing the host data. The memory subsystem 110 may write the host data to each available position of a page stripe of a unit (e.g., a data block) of the memory subsystem 110. Once the page stripe is full, the parity processing component 113 may generate corresponding parity data based on an XOR operation performed between each host data on the page stripe. The parity processing component 113 may store the parity data on a volatile memory of the memory subsystem. The memory subsystem 110 may continue to write additional host data to an additional page stripe of the memory subsystem 110. The parity processing component 113 may append (e.g., accumulate) the additional parity data to a set of parity data on the volatile memory based on the host data on the additional page stripe. The controller 115 may check to determine whether a size condition is met, for example, whether the size of the set of parity data on the volatile memory is equal to or greater than the size of the data of the entire page stripe. If the size condition is met, the controller 115 may store the set of parity data from the volatile memory to another page stripe of another unit of the memory subsystem 110. In this way, the controller 115 may separate the host data and the corresponding parity data in separate units of the memory subsystem 110. During a sequential read request, the memory subsystem 110 may perform a read operation on all available data locations of a unit storing host data without incurring any idle time associated with storing parity data on the unit. In the event of a read failure from a portion of the memory subsystem 110 storing host data, the memory subsystem 110 may reconstruct the host data using the set of parity data stored on the unit dedicated to storing parity data.

[0038] Figure 2 In some embodiments of the present disclosure, a memory subsystem (eg, Figure 1 1 and 2. An example of separating host data and parity data in different units, unit 201 and unit 202, of memory subsystem 110 is shown. Figure 1 Elements of the computing environment 100 may be used to help illustrate Figure 2 .exist Figure 2 In the example shown, the specific architecture of example memory subsystem unit 201 and unit 202 are shown.

[0039] In some embodiments, the memory device 130 of the memory subsystem 110 may include a set of logical unit numbers (LUNs) (unlabeled). In some embodiments, each LUN in a set of LUNs has the same amount of memory. In some embodiments, a LUN may correspond to a memory of a specific granularity, such as a die of the memory device 130. A die is the smallest unit that can execute commands independently. A single memory device 130 may include one or more dies configured in a discrete package. In the example shown, the memory subsystem 110 includes four dies (e.g., die 0 to die 3).

[0040] In some embodiments, a LUN may correspond to memory of different granularities, such as planes within a die. The same and concurrent operations may be performed on each plane. A single die may contain one or more planes. Figure 2 As shown, die 0 includes four planes P0 to P3. In the example shown, the memory device includes 4 dies, and each die includes 4 planes.

[0041] In some embodiments, data may be "striped" across multiple portions of the memory device 130, such as across multiple LUNs in a set of LUNs. Striping (also referred to herein as "page striping") may refer to the process of dividing a memory device into smaller segments across available portions of the memory device (e.g., channels, die, and planes). Typically, each stripe is spread horizontally across all channels, die, and planes available in the memory device. In an example, page stripes are generally used one after another in a sequential manner. Each cell in a page stripe is a portion of a fixed size (e.g., 16KB, etc.) that holds data. Multiple fixed-size portions of a page stripe. Striping is intended to allow parallelism (e.g., independent data accesses are performed in parallel) during read, write, and erase operations. In an example, if a LUN is defined to represent a plane, data may be striped across multiple planes. The group of data locations that store striped data is called a page stripe. In another example, a particular striping technique may stripe data across different die. Such as Figure 2As shown, the data to be stored in the memory device is striped across different planes. For example, the controller 115 can receive host data from the host system 120. The received data can be written in a manner that the controller 115 stripes the data across several parts of the memory device. For example, the data is written on plane 0 of die 0, plane 1 of die 0, plane 2 of die 0, plane 3 of die 0, etc. until the data has been written to the memory device 130. The data location group for storing striped data across multiple LUNs can be referred to as a page stripe. In the example shown, stripes 0 to stripe N are shown as being used to stripe host data across the memory device. For example, the host data is striped across planes 0 to plane 3 of die 0 to die 3 on stripe 0. Therefore, each stripe is shown as including a total of 16 planes. Units 201 to 202 can include a total of 64 page stripes (e.g., stripes 0 to stripes N).

[0042] In some embodiments, the LUN of the memory device 130 can be divided into smaller memory units. For example, the LUN can include multiple memory blocks. A block of memory (also referred to herein as a "data block") may refer to the smallest unit of the memory device 130 that can be erased in response to an erase operation. A memory block may include multiple memory pages. A memory page may refer to the smallest unit of the memory device 130 that can be written in response to a write operation. In the example shown, unit 201 can represent a data block of memory, such as "block A". Similarly, unit 202 can represent another data block of memory, "block B". The die 0 of the memory device 130 can include block A, block B, block N, etc.

[0043] In some embodiments, a channel may refer to a connection or coupling between two elements of a computing environment, such as a connection or coupling between a controller 115 and a memory device 130. In some embodiments, the controller 115 may communicate with the memory devices 130, 140, etc. using a channel. For example, the controller 115 may perform one or more memory operations, such as a write operation, a read operation, an erase operation, a map operation, or garbage collection, on the memory device 130. For example, the controller 115 may perform a write operation to write data received from the host system 120 to a corresponding LUN of the memory device using an appropriate channel. In the example shown, four channels (e.g., channel 0 to channel 3) are shown for the unit 201, with each die having a corresponding channel.

[0044] In an embodiment, when the memory subsystem 110 receives host data to be written to the memory subsystem 110 from the host 120, a cursor may be used to track the location of the data stripe where the received data is being stored. The cursor may be software, hardware, or a combination thereof that manages the execution of memory operations. The memory subsystem 110 may include an XOR calculator to perform an XOR operation when the memory subsystem writes data to each location of a given stripe on a given memory cell (e.g., P0, P1, etc. of Die 0 corresponding to Stripe 0 of Block A). For example, whenever a new data element is written to a new location of a page stripe to include the new data element in the parity calculation, the XOR calculator may recalculate the running parity data until the cursor is at the end of the stripe (e.g., P3 of Die 3 corresponds to Stripe 0). In some instances, the BIN corresponding to the active page stripe where the memory subsystem performs host writes (e.g., a buffer memory in a volatile memory) may be used to store the running parity data in a volatile memory, such as in an SRAM (static random access memory). The controller may maintain multiple BINs as required by the memory subsystem. When the cursor reaches the end of the stripe, the memory subsystem 110 may write the host data to the last position of the stripe, calculate parity data (e.g., R0) for the entire stripe (e.g., all 16 planes of stripe 0), and store the parity data in a volatile memory, such as a DRAM (dynamic random access memory). Volatile memory may provide fast access and calculation of data. The memory subsystem may start storing the next set of host data on the next page stripe (e.g., stripe 1), calculate running parity data using the next BIN in the volatile memory when the memory subsystem stores the next set of data, and store parity data (e.g., R1) corresponding to the next set of host data stored on the entire next page stripe (e.g., stripe 1) and previously stored parity data (e.g., R0) corresponding to the host data on the previous page stripe (e.g., stripe 0). The memory subsystem may continue to store other sets of host data on additional page stripes (e.g., stripes 2, 3, 4, etc.) and store additional parity data (e.g., R2, R3, R4, etc.) corresponding to the corresponding page stripes to the volatile memory. The memory subsystem may append the additional parity data (e.g., R2, R3, R4) to a set of parity data previously stored on the volatile memory (e.g., R0 and R1). Thus, the memory subsystem may accumulate and save an updated set of parity data in the volatile memory, including the additional parity data.

[0045] In an embodiment, the memory subsystem tracks the set of parity data stored on the volatile memory. The memory subsystem continuously or at specific intervals evaluates the set of parity data (e.g., R0, R1, R2, R3, etc.) stored in the volatile memory to determine whether the set of parity data meets the size condition. In some embodiments, the memory subsystem can determine whether the size of the set of parity data is equal to or greater than a specified size. In an example, the specified size can be the size of a full page of data of the memory unit. In another example, the size can be specified in kilobytes of memory. In some embodiments, the memory subsystem can determine whether the number of pages storing the set of parity data is equal to or greater than the specified number of pages. For example, the specified number can be the number of pages of a page stripe on the memory unit (e.g., block B). In another example, the number can be specified according to a predetermined number (e.g., 15 or 16 pages, etc.).

[0046] In some embodiments, when the memory subsystem determines that the set of parity data does not satisfy the size condition, the memory subsystem continues to accumulate and save additional parity data to the set of parity data on the volatile memory based on the corresponding host data stored in the corresponding page stripe until the size condition is satisfied.

[0047] In some embodiments, when the memory subsystem determines that the set of parity data satisfies the size condition, the memory subsystem may store the set of parity data stored on the volatile memory to another unit of the memory device 130. For example, the memory subsystem may determine that the set of parity data (e.g., R0 to R14) satisfies the size condition, for example, the size of the set of parity data is equal to the size of a full page stripe of data of the memory unit 202 (e.g., block B). In addition, the memory subsystem may determine that the number of pages storing the set of parity data (e.g., R0 to R14) is equal to 15 pages of data. Figure 2As shown, in response to determining that the size condition is satisfied, the memory subsystem may store the set of parity data (e.g., R0 to R14) on a page stripe (e.g., stripe 0) of a unit 202 (e.g., block B) of the memory device 130, which is a unit different from the unit 201. Thus, the memory subsystem 110 may separate the host data and the parity data in different memory units. Once the set of parity data is stored in different units of the memory device 130, the set of parity data is removed from the volatile memory, and a new cycle of calculating a different set of parity data for a different set of host data may be started. When the size of the new set of parity data satisfies the size condition, the new set of parity data may be stored on the next stripe (e.g., stripe 1) of the unit 202.

[0048] In some embodiments, the memory subsystem may designate cells (e.g., blocks) for storing host data exclusively and / or designate separate cells for storing parity data exclusively. In some instances, the memory subsystem may store the set of parity data corresponding to different cells (e.g., different blocks) of the memory device 130 within cells (e.g., cell 202) that are dedicated to storing parity data exclusively. For example, portions 210, 212, and 220 of cell 202 may store parity data corresponding to blocks A, B, and Z, respectively. The memory subsystem may use corresponding parity data of the set of parity data stored on cell 202 to reconstruct a piece of host data of the set of host data stored on cell 201 when the piece of host data cannot be read from cell 201 in the event of a failure associated with the memory device 130.

[0049] In some embodiments, the specified size of the size condition can be a predetermined number of data that is less than the size of a full stripe of pages. In some implementations, the specified number of pages for the size condition can be a predetermined number of pages that is less than the number of pages on a full stripe of pages. These types of size conditions can be defined to accommodate the storage of parity values ​​corresponding to the set of parity data stored on blocks dedicated to storing parity data. For example, Figure 2 As shown, the last plane of die 3 of stripe 0 of unit 202 is used to store parity data based on the XOR operation in the set of parity data in the previous planes (R0 to R14) of stripe 0. In the event of a failure in the data location storing the parity data, the parity value corresponding to the set of parity data can be used to recover the parity data of the set of parity data.

[0050] In some embodiments, instead of storing the set of parity data when the size condition is met, the parity data may be stored in cells separate from the host data as long as a full page of host data is stored on the host data cells. That is, for example, after the host data is stored in the full page stripe 0 and the parity data corresponding to stripe 0 of cell 201 is calculated, the parity data may be stored at die 0, plane 0 of stripe 0 in cell 202. The parity data corresponding to the full page stripe 0 may be stored in cell 202 without first having to be stored in volatile memory, which may avoid accumulating parity data until the full page stripe of parity data has been accumulated, thereby avoiding large capacity in volatile memory.

[0051] Figure 3 is an example of a relationship between separate host data and parity data in different memory subsystem units according to some embodiments of the present disclosure. In an embodiment, the memory subsystem may implement a mechanism to create a relationship between host data stored in a particular page stripe of one memory unit and parity data on different memory units corresponding to the particular page stripe of host data. In some examples, the memory subsystem may utilize additional fields in the page header of the page storing the host data and the parity data. The additional fields may be used to identify the location where the corresponding parity data is stored, and vice versa. For example, Figure 3 It is shown that plane P0 of die-0 corresponding to page stripe 0 of unit 201 (e.g., block A) contains "header+data", while plane P0 of die-0 corresponding to page stripe 0 of unit 202 (e.g., block B) contains "header+R0". When the memory subsystem 110 writes host data into unit 201, the memory subsystem can add additional fields for containing the corresponding parity data location within the header. Figure 2 In the example shown, the header information may include the following:

[0052] For page stripe 0 at (die-0 to die-3)(P0 to P3), the header points to “unit 202, page stripe 0, die 0, P0;

[0053] For page stripe 1 at (die-0 to die-3)(P0 to P3), the header points to “unit 202, page stripe 0, die 0, P1;

[0054] For page stripe 2 at (die-0 to die-3)(P0 to P3), the header points to "unit 202, page stripe 0, die 0, P2;

[0055] For page stripe 3 at (Die-0 to Die-3)(P0 to P3), the header points to "Cell 202, Page Stripe 0, Die 0, P3.

[0056] On the other hand, when the memory subsystem 110 writes parity data in the cell 202, the memory subsystem may add an additional field within each header for containing the corresponding host data location based on which the parity data at the page was generated. Figure 2 In the example shown, the header information in the parity data page may include the following:

[0057] For page stripe 0, die-0, P0 (e.g., parity R0), the header points to the parity derived from "unit 201, page stripe 0";

[0058] For page stripe 0, die-0, P1 (e.g., parity R1), the header points to the parity derived from "unit 201, page stripe 1";

[0059] For page stripe 0, die-0, P2 (e.g., parity R2), the header points to the parity from "unit 201, page stripe 2";

[0060] For Page Stripe 0, Die-0, P3 (eg, Parity R3), the header points to the parity from "Unit 201, Page Stripe 3".

[0061] In the event of a read failure on a portion of the memory device storing host data, the memory subsystem can refer to the header field to identify where the corresponding parity data is located and use the parity data to reconstruct the host data.

[0062] In some embodiments, the relationship identified between the host data and the parity data can be used to improve device initialization. For example, the memory subsystem can store the relationship information available in the parity data header in a control structure (e.g., a file) with a pre-allocated file ID for later use. Since the parity data header points to each block location from which the parity data is generated, a complete list of all data locations of the host data stored in the memory device is available in the parity header corresponding to the full set of parity data. When the memory device is initialized to perform a memory operation, the memory subsystem can skip scanning all data blocks to identify the data block locations storing programmed data, and instead use a control structure to identify the data block locations storing host data. Therefore, the use of a control structure can save time that would otherwise be spent during device initialization.

[0063] Figure 4is a flow chart of an example method for storing parity data in a volatile memory until a size condition is satisfied before separating the parity data and host data in different cells of a memory device according to some embodiments of the present disclosure. The method 400 may be performed by processing logic, which may include hardware (e.g., a processing device, a circuit, dedicated logic, programmable logic, microcode, hardware of a device, an integrated circuit, etc.), software (e.g., instructions running or executed on a processing device), or a combination thereof. In some embodiments, the method 400 is performed by Figure 1 The parity check processing component 113 shown in the figure is executed. Although shown in a specific order or sequence, unless otherwise specified, the order of the process can be modified. Therefore, the illustrated embodiment should only be understood as an example, and the illustrated process can be performed in different orders and some processes can be performed in parallel. In addition, one or more processes can be omitted in various embodiments. Therefore, not all processes are needed in each embodiment. Other process flows are also possible.

[0064] At operation 410, processing logic accumulates parity data to a set of parity data on a volatile memory, the parity data being based on a set of host data on a page stripe of a first unit of a memory device. In some instances, the volatile memory may include an SRAM or a DRAM. In some instances, the parity data is generated based on an XOR operation performed between the set of host data on the page stripe. In some instances, the parity data may be Redundant Array of Independent NAND (RAIN) parity data.

[0065] At operation 420, processing logic determines whether the set of parity data satisfies a size condition. In some instances, the set of parity data satisfies the size condition when a first size of the set of parity data is equal to or greater than a second size of data for an entire page stripe on the second unit. In some other instances, the set of parity data satisfies the size condition when a first number of pages storing the set of parity data is equal to or greater than a second number of pages for a page stripe on the second unit.

[0066] At operation 430, processing logic proceeds to append additional parity data to the set of parity data in response to determining that the set of parity data does not satisfy the size condition, the additional parity data being based on one or more sets of corresponding host data on the one or more corresponding additional page stripes. In some examples, the first unit is dedicated to exclusively store host data.

[0067] At operation 440, processing logic stores the set of parity data in a second unit of the memory device in response to determining that the set of parity data satisfies the size condition. In some instances, the first unit is different from the second unit. In some instances, the second unit is dedicated to exclusively storing parity data. Additionally, when host data is not readable from the first unit, processing logic uses corresponding parity data of the set of parity data on the second unit to reconstruct host data of the set of host data stored on the first unit.

[0068] Figure 5 1 is a flow chart of an example method 500 for separating parity data from host data in a memory subsystem according to some embodiments of the present disclosure. The method 500 may be performed by processing logic, which may include hardware (e.g., a processing device, a circuit, dedicated logic, programmable logic, microcode, hardware of a device, an integrated circuit, etc.), software (e.g., instructions running or executed on a processing device), or a combination thereof. In some embodiments, the method 500 is performed by Figure 1 The parity check processing component 113 shown in the figure is executed. Although shown in a specific order or sequence, unless otherwise specified, the order of the process can be modified. Therefore, the illustrated embodiment should only be understood as an example, and the illustrated process can be performed in different orders and some processes can be performed in parallel. In addition, one or more processes can be omitted in various embodiments. Therefore, not all processes are needed in each embodiment. Other process flows are also possible.

[0069] At operation 510, processing logic performs a plurality of write operations to write a set of host data to a first unit of a memory subsystem. In some instances, the first unit may represent a data block. At operation 520, processing logic generates a set of parity data based on the host data. In some instances, the parity data may be Redundant Array of Independent NAND (RAIN) parity data.

[0070] At operation 530, processing logic determines whether the set of parity data satisfies a size condition. In some instances, the set of parity data satisfies the size condition when a first size of the set of parity data is equal to or greater than a second size of data for a full stripe of pages on the second unit. In some instances, the set of parity data satisfies the size condition when a first number of pages storing the set of parity data is equal to or greater than a second number of pages for a stripe of pages on the second unit.

[0071] At operation 540, processing logic stores a set of parity data on a second unit of the memory subsystem. In some instances, the first unit is different from the second unit. In some instances, the first unit is dedicated to exclusively storing host data. In some instances, the second unit is dedicated to exclusively storing parity data. Additionally, in response to determining that the set of parity data does not meet the size condition, processing logic stores the set of parity data on a random access memory. Furthermore, when host data cannot be read from the first unit, processing logic uses parity data of the set of parity data on the second unit to reconstruct host data of the set of host data stored on the first unit.

[0072] Figure 6 An example machine of a computer system 600 is shown within which a set of instructions for causing the machine to perform any one or more of the methodologies discussed herein may be executed. In some embodiments, the computer system 600 may correspond to a host system (e.g., Figure 1 The host system 120 is shown. The host system includes, is coupled to, or utilizes a memory subsystem (e.g., Figure 1 110), or can be used to execute the operation of the controller (for example, execute the operating system to execute the corresponding Figure 1 In some embodiments, the machine may be connected (e.g., using a network) to other machines in a LAN, an intranet, an extranet, and / or the Internet. The machine may operate in the capacity of a server or a client machine in a client-server network environment, in a peer-to-peer (or distributed) network environment, or in a cloud computing infrastructure or environment.

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

[0074] The example computer system 600 includes a processing device 602, a main memory 604 (e.g., read-only memory (ROM), flash memory, dynamic random access memory (DRAM) such as synchronous DRAM (SDRAM) or RDRAM), a static memory 606 (e.g., flash memory, static random access memory (SRAM), etc.), and a data storage system 618, which communicate with each other via a bus 630.

[0075] The processing device 602 represents one or more general processing devices, such as a microprocessor, a central processing unit, etc. More specifically, the processing device may be a complex instruction set computing (CISC) microprocessor, a reduced instruction set computing (RISC) microprocessor, a very long instruction word (VLIW) microprocessor, or a processor that implements other instruction sets, or a processor that implements a combination of instruction sets. The processing device 602 may also be one or more special-purpose processing devices, such as an application-specific integrated circuit (ASIC), a field programmable gate array (FPGA), a digital signal processor (DSP), a network processor, etc. The processing device 602 is configured to execute instructions 626 for performing the operations and steps discussed herein. The computer system 600 may further include a network interface device 608 to communicate via a network 620.

[0076] The data storage system 618 may include a machine-readable storage medium 624 (also referred to as a computer-readable medium) on which is stored one or more sets of instructions 626 or software embodying any one or more of the methods or functions described herein. The instructions 626 may also reside, in whole or in part, within the main memory 604 and / or within the processing device 602, which during execution thereof by the computer system 600 also constitute machine-readable storage media. The machine-readable storage medium 624, the data storage system 618, and / or the main memory 604 may correspond to Figure 1 Memory subsystem 110 is shown.

[0077] In an embodiment, the instructions 626 include instructions for implementing a method corresponding to a parity processing component (e.g., Figure 1 113). Although the machine-readable storage medium 624 is shown as a single medium in the example embodiment, the term "machine-readable storage medium" should be considered to include a single medium or multiple media storing one or more sets of instructions. The term "machine-readable storage medium" should also be considered to include any medium capable of storing or encoding a set of instructions for execution by a machine and causing the machine to perform any one or more methods of the present disclosure. Therefore, the term "machine-readable storage medium" should be considered to include, but not limited to, solid-state memory, optical media, and magnetic media.

[0078] Some parts of the above detailed description have been expressed as algorithms and symbolic descriptions of the operations of data bits in computer memory. These algorithmic descriptions and expressions are commonly used by technicians in the field of data processing, so as to most effectively transfer their work essence to technicians in other fields. The algorithm herein generally refers to a self-consistent sequence of operations that obtain a desired result. These operations are operations that require physical manipulation of physical quantities. Usually, although not necessarily, these quantities take the form of electrical or magnetic signals that can be stored, combined, compared and otherwise manipulated. Sometimes, mainly for the reasons of public use, these signals are referred to as bits, values, elements, symbols, characters, items, numbers, or similar names, which have been proven to be convenient.

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

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

[0081] The algorithms and displays presented herein are not inherently related to any particular computer or other device. Various general purpose systems may be used with programs according to the teachings herein, or it may prove convenient to construct more specialized devices to perform the methods. The structures of a variety of these systems will be apparent from the following description. In addition, the present disclosure is described without reference to any particular programming language. It will be appreciated that a variety of programming languages ​​may be used to implement the teachings of the present disclosure described herein.

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

[0083] In the foregoing description, embodiments of the present disclosure have been described with reference to specific example embodiments of the present disclosure. Obviously, various modifications may be made thereto without departing from the broader spirit and scope of the embodiments of the present disclosure as set forth in the appended claims. Therefore, the description and drawings are to be regarded as illustrative rather than restrictive.

Claims

1. A system comprising: Memory device; Volatile memory; as well as a processing device operatively coupled to the memory device and the volatile memory to: appending parity data to a set of parity data on the volatile memory, the parity data being based on a set of host data on a page stripe of a first cell of the memory device; determining whether the set of parity check data satisfies a size condition; In response to determining that the set of parity data does not satisfy the size condition, proceeding to append additional parity data to the set of parity data, the additional parity data being based on one or more corresponding sets of host data on one or more corresponding additional page stripes; and In response to determining that the set of parity data satisfies the size condition, the set of parity data is stored in a second unit of the memory device.

2. The system according to claim 1, wherein the processing device is used to: When the host data cannot be read from the first unit, host data of the set of host data stored on the first unit is reconstructed using corresponding parity data of the set of parity data on the second unit.

3. The system of claim 1, wherein the set of parity data satisfies the size condition when a first size of the set of parity data is equal to or greater than a second size of data of a whole page stripe on the second unit.

4. The system of claim 1, wherein the set of parity data satisfies the size condition when a first number of pages storing the set of parity data is equal to or greater than a second number of pages of one page stripe on the second unit. The system of claim 1 , wherein the first unit is different from the second unit.

6. The system of claim 1, wherein the first unit is dedicated to exclusively storing host data.

7. The system of claim 1, wherein the second unit is dedicated to exclusively storing parity data.

8. A method comprising: performing a plurality of write operations to write a set of host data on a first unit of the memory subsystem; generating a set of parity data based on the host data; determining whether the set of parity check data satisfies a size condition; and In response to determining that the set of parity data satisfies the size condition, the set of parity data is stored, by the processing device, on a second unit of the memory subsystem.

9. The method according to claim 8, further comprising: In response to determining that the set of parity data does not satisfy the size condition, the set of parity data is stored on a random access memory by the processing device.

10. The method according to claim 8, further comprising: When the host data cannot be read from the first unit, host data of the set of host data stored on the first unit is reconstructed using parity data of the set of parity data on the second unit.

11. The method of claim 8, wherein the set of parity data satisfies the size condition when a first size of the set of parity data is equal to or greater than a second size of data of a whole page stripe on the second unit.

12. The method of claim 8, wherein the set of parity data satisfies the size condition when a first number of pages storing the set of parity data is equal to or greater than a second number of pages of one page stripe on the second unit. The method of claim 8 , wherein the first unit is different from the second unit.

14. The method of claim 8, wherein the second unit is dedicated to exclusively storing parity data.

15. A non-transitory computer-readable storage medium comprising instructions that, when executed by a processing device, cause the processing device to: appending parity data to a set of parity data on the volatile memory, the parity data being based on a set of host data on a page stripe of a first cell of the memory device; determining whether the set of parity check data satisfies a size condition; In response to determining that the set of parity data does not satisfy the size condition, proceeding to append additional parity data to the set of parity data, the additional parity data being based on one or more corresponding sets of host data on one or more corresponding attached extra stripes; and In response to determining that the set of parity data satisfies the size condition, the set of parity data is stored in a second unit of the memory device.

16. The non-transitory computer-readable storage medium of claim 15, wherein the processing device is further configured to: When the host data cannot be read from the first unit, host data of the set of host data stored on the first unit is reconstructed using corresponding parity data of the set of parity data on the second unit.

17. The non-transitory computer-readable storage medium of claim 15, wherein the set of parity data satisfies the size condition when a first size of the set of parity data is equal to or greater than a second size of data of a whole page stripe on the second unit.

18. The non-transitory computer-readable storage medium of claim 15, wherein the set of parity data satisfies the size condition when a first number of pages storing the set of parity data is equal to or greater than a second number of pages of one page stripe on the second unit.

19. The non-transitory computer-readable storage medium of claim 15, wherein the first unit is different from the second unit.

20. The non-transitory computer-readable storage medium of claim 15, wherein: The first unit is dedicated to storing host data, and the second unit is dedicated to storing parity data.