Snapshot read optimization for media management of memory subsystems

Abstract

This application relates to snapshot read optimization for media management of a memory subsystem. A plurality of entries associated with a media management operation of a plurality of transfer units are stored. A respective destination location for each of the respective transfer units is determined in connection with a garbage collection process such that a subset of the plurality of transfer units is aligned with a codeword boundary on a memory page. A plurality of write commands related to the media management operation are issued based at least in part on the determination.

Description

[0001] Information related to divisional application

[0002] This application is a divisional application. Its parent application is the invention patent application filed on December 17, 2020, with application number 202011493111.2 and title "Snapshot Reading Optimization for Media Management of Memory Subsystem".

[0003] Cross-references

[0004] This patent application claims priority to U.S. Patent Application No. 16 / 721,712, filed December 19, 2019, entitled “Snapshot Read Optimization for Media Management of Memory Subsystem” by Bianco et al., which is assigned to the assignee and is expressly incorporated herein by reference in its entirety. Technical Field

[0005] The technical field relates to snapshot read optimization for media management in memory subsystems. Background Technology

[0006] The memory subsystem may include one or more memory components for storing data. Memory components may be, for example, non-volatile memory components and volatile memory components. Generally, a host system can utilize the memory subsystem to store data at the memory components and retrieve data from the memory components. Summary of the Invention

[0007] A method is described. In some instances, the method includes: storing a plurality of entries associated with a set of media management operations for a plurality of delivery units, each entry including the location of a corresponding delivery unit among the plurality of delivery units on a memory page associated with a memory subsystem; determining a corresponding destination location for each of the corresponding delivery units associated with the set of media management operations such that a subset of the plurality of delivery units is aligned with codeword boundaries on the memory page; and issuing a plurality of write commands associated with the set of media management operations, at least in part based on the determination, each write command including an instruction to write one delivery unit from the subset to the corresponding destination location on the memory page.

[0008] A system is described. In some instances, the system may include a plurality of memory devices and a processing device operatively coupled to the plurality of memory devices to: store a plurality of entries corresponding to a plurality of transfer units associated with a set of media management operations for the plurality of memory devices; determine a corresponding destination location for each of the plurality of transfer units such that a subset of the plurality of transfer units corresponds to a codeword on a memory page; and issue a plurality of write commands associated with the set of media management operations, at least in part based on the determination, the plurality of write commands including instructions to write a subset of the plurality of transfer units to the corresponding destination location on the memory page.

[0009] A non-transitory computer-readable storage medium is described. In some instances, the non-transitory computer-readable storage medium may contain instructions that, when executed by a processing means, cause the processing means to: store a plurality of entries associated with a set of media management operations for a plurality of transfer units, each entry including the location of a corresponding transfer unit of the plurality of transfer units on a memory page associated with a memory subsystem; determine a destination location for each of the corresponding transfer units associated with the set of media management operations such that a subset of the plurality of transfer units is aligned with a codeword boundary on the memory page; and issue a plurality of write commands associated with the set of media management operations, at least in part based on the determination, each write command including an instruction to write one transfer unit of the subset to the corresponding destination location on the memory page. Attached Figure Description

[0010] This disclosure will be more fully understood from the detailed description given below and the accompanying drawings of various examples of this disclosure. However, the drawings are not intended to limit this disclosure to specific examples, but are for explanation and understanding only.

[0011] Figure 1 This describes an instance computing system including a memory subsystem, based on some examples of this disclosure.

[0012] Figure 2 This is a flowchart of an example method for optimizing snapshot reading for media management of a storage subsystem, based on some examples of this disclosure.

[0013] Figure 3 This is a block diagram of an example method for optimizing snapshot reading for media management of a memory subsystem, based on some examples of this disclosure.

[0014] Figure 4 This is a diagram of an instance scoreboard for performing snapshot read optimizations for media management of a memory subsystem, based on some examples of this disclosure.

[0015] Figure 5 This is a block diagram of an instance computer system that can operate on an example of this disclosure. Detailed Implementation

[0016] This disclosure relates to a snapshot read optimization for media management in a memory subsystem. The memory subsystem may be a storage device, a memory module, or a hybrid of a storage device and a memory module. The following is combined with… Figure 1 Describe examples of storage devices and memory modules. Generally, a host system may utilize a memory subsystem that contains one or more memory devices for storing data. The host system can provide data to be stored in the memory subsystem and can request to retrieve data from the memory subsystem.

[0017] Memory devices can be non-volatile memory devices. A non-volatile memory device is a package of one or more dies. Each die may consist of one or more planes. For some types of non-volatile memory devices (e.g., NAND devices), each plane consists of a set of physical blocks. Each block consists of a set of pages. Each page consists of a set of memory cells storing data bits. For some memory devices, such as NAND devices, a block is the smallest erasable area and the pages within a block cannot be erased individually. For such devices, erase operations are performed one block at a time.

[0018] Pages within a block may contain valid data, invalid data, or no data. Invalid data is data marked as obsolete because a newer version of that data is stored on the memory device. Invalid data includes data previously written but no longer associated with a valid logical address (e.g., a logical address referenced by the host system in a physical-to-logical (P2L) mapping table). Valid data is the most recent version of this data currently stored on the memory device. The memory subsystem may mark data as invalid based on information received, for example, from the operating system. Pages containing no data contain pages that have been previously erased and have not yet been written to.

[0019] The memory subsystem controller can perform operations for media management algorithms (such as wear leveling, refresh, garbage collection, erase, etc.). A block may have some pages containing valid data and some pages containing invalid data. To avoid waiting for all pages in a block to have invalid data before erasing and reusing the block, an algorithm referred to below as "garbage collection" can be invoked to allow the block to be erased and freed as an idle block for subsequent write operations. Garbage collection is a set of media management operations that include, for example: selecting a block containing valid and invalid data; selecting pages in the block containing valid data; copying the valid data to a new location (e.g., a free page in another block); marking data in the previously selected pages as invalid; and erasing the selected block.

[0020] The term "garbage collection" in the following text refers to selecting blocks; rewriting valid data from the selected blocks to another block; and erasing all invalid and valid data stored in the selected blocks. Valid data from multiple selected blocks can be copied to a smaller number of other blocks, and the selected blocks can then be erased. Therefore, the number of erased blocks can be increased, making more blocks available for storing subsequent data from the host system.

[0021] During garbage collection, based on one or more read commands issued by the memory subsystem controller, the valid data of the block to be erased is initially read into and stored in a buffer, and the corresponding page (e.g., a page that may contain valid data) is erased. The valid data can then be written (e.g., rewritten) to the memory device (e.g., a different page of the memory device).

[0022] During a snapshot read process, a single codeword (containing multiple TUs) can be read based on a single read command. For a snapshot read to be performed successfully, the data used for the snapshot read (one or more TUs) is aligned with the codeword boundaries on a page of the memory device. However, in some cases, data may span multiple codewords on a page of the memory device, causing a set of data of a given size (e.g., 4 kilobytes (KB) or 8 KB) to be misaligned with the codeword boundaries on a page of the memory device. Since data misaligned with codeword boundaries does not meet the requirements for a snapshot read, arranging data in this way degrades the performance and likelihood of snapshot read operations.

[0023] This disclosure addresses the aforementioned and other deficiencies by incorporating a memory subsystem comprising a scoreboard for grouping entries based on codewords associated with data (e.g., during a garbage collection process). For example, when a TU is read from a block during a garbage collection process, the scoreboard can group entries according to the codeword boundaries from which the TU is read. For example, the entries on the scoreboard can be sorted such that valid TUs are aligned with codeword boundaries on pages of the memory device. Therefore, valid data can be written to a destination location (e.g., a block) based on codeword boundaries. By maintaining or aligning with codeword boundaries during the garbage collection process, the overall performance of the memory subsystem is increased, and data that previously met the conditions for a snapshot read can be written, thus still meeting the conditions for a snapshot read, which improves the read performance of the memory subsystem.

[0024] Figure 1 This description describes an example computing system 100 including a memory subsystem 110 according to some embodiments of the present disclosure. The computing environment may include a host system 105 and a memory subsystem 110. The memory subsystem 110 may include media, such as one or more non-volatile memory devices (e.g., memory device 130), one or more volatile memory devices (e.g., memory device 140), or a combination thereof.

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

[0026] The computing system 100 may be a computing device, such as a desktop computer, laptop computer, web server, mobile device, vehicle (e.g., airplane, drone, train, car or other means of transport), device with Internet of Things (IoT) capabilities, embedded computer (e.g., embedded computer contained in a vehicle, industrial equipment or networked business device), or such computing device containing memory and processing devices.

[0027] The computing system 100 may include a host system 105 coupled to one or more memory subsystems 110. In some instances, the host system 105 is coupled to memory subsystems 110 of different types. Figure 1 This describes an example of a host system 105 coupled to a memory subsystem 110. As used herein, “coupled to…” or “coupled with…” generally refers to a connection between components, which can be an indirect or direct communication connection (e.g., without an intervening component), whether wired or wireless, and includes connections such as electrical, optical, magnetic, etc.

[0028] Host system 105 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). Host system 105 uses memory subsystem 110, for example, to write data to memory subsystem 110 and to read data from memory subsystem 110.

[0029] Host system 105 can be coupled to memory subsystem 110 using a physical host interface. Examples of physical host interfaces include, but are not limited to, Serial Advanced Technology Attachment (SATA) interfaces, Peripheral Component Interconnect High Speed ​​(PCIe) interfaces, Universal Serial Bus (USB) interfaces, Fibre Channel, Small Computer System Interface (SCSI), Serial Attached SCSI (SAS), Dual In-line Memory Module (DIMM) interfaces (e.g., DIMM sockets supporting Dual Data Rate (DDR)). The physical host interface can be used to transfer data between host system 105 and memory subsystem 110. When memory subsystem 110 is coupled to host system 105 via a PCIe interface, host system 105 can further utilize a Non-Volatile Memory Fast (NVMe) interface to access memory components (e.g., memory device 130). The physical host interface provides an interface for passing control, address, data, and other signals between memory subsystem 110 and host system 105.

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

[0031] Some examples of nonvolatile memory devices (e.g., memory device 130) include NAND flash memory. Another example of a nonvolatile memory device is a write-in-place memory, such as a three-dimensional crosspoint (“3D crosspoint”) memory. A crosspoint array of nonvolatile memory can be combined with a stackable cross-grid data access array to perform bit storage based on changes in volume resistance. Furthermore, compared to many flash-based memories, crosspoint nonvolatile memory can perform write-in-place operations, where nonvolatile memory cells can be programmed without pre-erasing them.

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

[0033] Although a non-volatile memory device such as NAND flash memory has been described, memory device 130 may be based on any other type of non-volatile memory, such as read-only memory (ROM), phase-change memory (PCM), selectable memory, other chalcogenide-based memory, ferroelectric RAM (FeRAM), magnetic RAM (MRAM), NOR flash memory, electrically erasable programmable ROM (EEPROM).

[0034] The memory subsystem controller 115 (or simply 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 may include hardware, such as one or more integrated circuits and / or discrete components, buffer memories, or combinations thereof. The hardware may include a digital circuit system with dedicated (i.e., hard-decoded) logic to perform the operations described herein. The memory subsystem controller 115 may be a microcontroller, dedicated logic circuitry (e.g., a field-programmable gate array (FPGA), an application-specific integrated circuit (ASIC), a digital signal processor (DSP)), or other suitable processor.

[0035] The memory subsystem controller 115 may include a processor 120 (e.g., a processing device) configured to execute instructions stored in local memory 125. In the illustrated example, the local memory 125 of the memory subsystem controller 115 includes embedded memory configured to store instructions for performing various processes, operations, logical flows, and routines for controlling the operation of the memory subsystem 110, including handling communication between the memory subsystem 110 and the host system 105.

[0036] In some instances, local memory 125 may include memory registers that store memory pointers, fetched data, etc. Local memory 125 may also include read-only memory (ROM) for storing microcode. Although Figure 1 The instance memory subsystem 110 has been shown to include a memory subsystem controller 115, but in another embodiment of this disclosure, the memory subsystem 110 does not include a 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).

[0037] Typically, the memory subsystem controller 115 receives commands or operations from the host system 105 and translates these commands or operations into instructions or appropriate commands to perform the desired access to the memory device 130. The memory subsystem controller 115 may handle other operations such as wear leveling, garbage collection, error detection and error correction (ECC) operations, encryption, caching, and address translation between logical addresses (e.g., logical block addresses, namespaces) and physical addresses (e.g., physical block addresses) associated with the memory device 130. The memory subsystem controller 115 may further include a host interface circuitry for communicating with the host system 105 via a physical host interface. The host interface circuitry translates commands received from the host system into instructions for accessing the memory device 130 and translates responses associated with the memory device 130 into information for the host system 105.

[0038] The memory subsystem 110 may also include additional circuitry or components not described. In some instances, the memory subsystem 110 may include caches or buffers (e.g., DRAM) and address circuitry (e.g., row decoders and column decoders) that can receive addresses from the memory subsystem controller 115 and decode the addresses to access the memory device 130.

[0039] In some embodiments, memory device 130 includes a local media controller 135, which operates in conjunction with memory subsystem controller 115 to perform operations on one or more memory cells of memory device 130. An external controller (e.g., memory subsystem controller 115) may externally manage memory device 130 (e.g., perform media management operations on memory device 130). In some embodiments, memory device 130 is a managed memory device, which is a raw memory device combined with a local controller (e.g., 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.

[0040] The memory subsystem 110 includes a codeword manager 150 capable of performing media management operations, wherein data can be migrated from one location to another independently of any direct host system interaction. In some instances, the codeword manager 150 may bundle valid data together to free up space for new writes, error prevention, wear leveling, and / or recovery of independent node Redundant Array of Independent Nodes (RAIN) parity protection in the event of an error. Alternatively or concurrently, the codeword manager 150 may move or copy data from one or more blocks (e.g., one or more blocks of NAND cells) to a destination block based on one or more codeword boundaries associated with the data.

[0041] In some instances, the memory subsystem controller 115 includes at least a portion of the codeword manager 150. For example, the memory subsystem controller 115 may include a processor 120 (e.g., a processing device) configured to execute instructions stored in local memory 125 for performing the operations described herein. In some instances, the codeword manager 150 is part of the host system 105, an application, or an operating system.

[0042] The codeword manager 150 can store various entries associated with media management operations and determine the codeword boundaries associated with each entry. For example, the codeword manager 150 can group one or more entries based on the boundaries of each entry. After a block has been erased by the codeword manager 150 or another component, pages of valid data can be written (e.g., rewritten) to the block based on the grouping. That is, the codeword manager 150 can preserve the order of data (e.g., TU) within a codeword to ensure that the data can be read in subsequent snapshot reads. For example, a data block spanning multiple pages containing both valid and invalid data can be written to one or more codewords to maintain compliance with the conditions for future snapshot reads. Further details regarding the operation of the codeword manager 150 are described below.

[0043] Figure 2 This is a flowchart 200 illustrating an example method for optimizing snapshot reading for media management of a memory subsystem, according to some examples of this disclosure. The method illustrated in flowchart 200 can be executed by processing logic, which may include hardware (e.g., processing device, circuit system, dedicated logic, programmable logic, microcode, device hardware, integrated circuit, etc.), software (e.g., instructions running or executed on the processing device), or a combination thereof. In some examples, the method illustrated in flowchart 200 is performed by… Figure 1The codeword manager 150 executes. Although shown in a specific sequence or order, the order of operations may be modified unless otherwise specified. Therefore, it should be understood that the examples shown are merely examples, and the operations shown may be executed in different orders, and some operations may be executed in parallel. Furthermore, one or more operations may be omitted in various instances. Therefore, not all operations are required in every instance. Other method flows are possible.

[0044] At operation 205, the processing apparatus may store a set of entries associated with a set of media management operations for a set of transfer units (TUs). In some instances, each entry may contain the location of the corresponding TU in the set of TUs on a memory page associated with the memory subsystem. In some instances, the method illustrated in flowchart 200 may include sorting the set of entries at least in part based on the location of the corresponding TU. In some instances, the corresponding destination location may be determined at least in part based on the sorting. In some instances, the method illustrated in flowchart 200 may include sorting the set of entries such that entries corresponding to a subset of the set of TUs are contiguous. In some instances, the method illustrated in flowchart 200 may include sorting the set of entries according to a sorting algorithm that groups entries of a subset of the set of TUs at least in part based on the codeword size of the memory page. In some instances, each of the subsets of the set of TUs corresponds to a codeword size. In some instances, the data size corresponding to the subset of the set of TUs is the same as the codeword size associated with the codeword boundary on the memory page.

[0045] At operation 210, the processing device may determine a corresponding destination location for each of the corresponding TUs associated with the set of media management operations, such that a subset of the set of TUs is aligned with a codeword boundary on a memory page. In some instances, the method illustrated in flowchart 200 may include determining a corresponding destination location for a second subset of the set of TUs, such that the second subset is aligned with a second codeword boundary on a memory page. In some instances, the second subset may not overlap with the first subset.

[0046] At operation 215, the processing device may, at least in part, issue a set of write commands associated with the set of media management operations based on the determination. In some instances, each write command may include instructions to write a subset of TUs to a corresponding destination location on a memory page. In some instances, the method illustrated in flowchart 200 may include performing a read operation on a subset of the set of TUs after issuing the set of write commands.

[0047] Figure 3Figure 300 illustrates an example of a method for optimizing snapshot reads for media management of a memory subsystem, based on the examples disclosed herein. Method Figure 300 illustrates the stages for identifying valid data (e.g., in stage 305), reading valid data (e.g., in stage 310), and issuing a write command (e.g., in stage 315). In some instances, as referenced... Figure 3 The operations described and performed can be implemented at the memory subsystem and can utilize the scoreboard 302. Furthermore, the operations can be performed based on the operations of the host system and / or the local media controller, and can be implemented based on the state machine settings. In some instances, method diagram 300 may illustrate one or more processes used to optimize snapshot reads during media management operations (e.g., range streaming process 320 and replay streaming process 325).

[0048] Method Figure 300 illustrates one or more operations for media management (e.g., media management operations for garbage collection). During media management operations, data can be migrated from one location (e.g., from a source memory address) to another location (e.g., to a destination memory address) independently of any direct host system interaction. Garbage collection can be performed to bundle valid data together to free up space for new writes, error prevention, wear leveling, and / or restoration of RAIN parity protection in the event of an error. Alternatively or concurrently, garbage collection may consist of moving or copying data from one or more source blocks (e.g., one or more NAND cell blocks) to one or more destination blocks. In some instances, garbage collection may cause data merging to free up resources (e.g., NAND cells) for subsequent erase and new write processing.

[0049] In some instances, the data transferred during media management operations may be, or referred to as, a transfer unit (TU), and may be controlled by the memory subsystem controller (e.g., by a reference...). Figure 1 The described processor 120), local media controller, or host system (e.g., Figure 1The minimum size of data managed internally by the host system 105. One or more TUs may be associated with a codeword (e.g., located within a codeword) and may correspond to a logical address (e.g., a TU address (TUA)) and a physical address (e.g., an abstract physical address that may be associated with the physical address of a NAND cell called a Platform Physical Address (PPA), such as a Flash Logic Address (FLA)). To consolidate data and / or free resources for subsequent access operations, TUs may be written to a new location (e.g., a destination address), and the original block (e.g., the block from which TUs were moved) may be erased. Candidates (e.g., blocks) for garbage collection may be selected using a number (pool, list, queue, etc.). In some instances, candidates may be maintained by a scoreboard 302. As described herein, it may be advantageous to write TUs to new blocks such that a given set of TUs resides within the boundaries of the same codeword to allow the written data to remain compliant with snapshot read conditions. That is, it may be advantageous to write TUs to new blocks in the same manner as the TUs were originally written by the host system. Maintaining consistent codeword boundaries during write operations can improve the overall performance of the memory subsystem.

[0050] To move (e.g., write) a valid TU to a destination block within the same codeword, a scoreboard 302 can be used to group entries associated with the valid TU before writing the TU to the destination block. Each entry may contain at least the TUA and FLA associated with the TU. Alternatively, among other parameters that may be included in the linked list, the linked list may contain a next node identifier. The next node identifier may indicate the subsequent TU for media management operations. Thus, using a list where each entry indicates the next (e.g., subsequent) TU allows valid TUs to be written to the destination block, aligning the TU with the specific codeword boundary.

[0051] In some instances, one or more entries may be maintained by scoreboard 302. Entries may consist of a list (e.g., queue, pool, etc.) of TUs used for media management operations. For example, a read operation may occur, and the TUA and / or FLA of each TU may be stored (e.g., grouped) to scoreboard 302 based on the codeword associated with the TU. Storing each TUA and / or FLA may generate a list (e.g., linked list) at scoreboard 302. The order of the list (e.g., the order in which read commands are grouped based on associated codewords) allows TUs to be written to the destination block, such that the boundaries of the TUs are aligned with the associated codewords. In other instances, the order of the linked list may be dynamically calculated using a prediction algorithm (e.g., an algorithm for predicting the order in which a host system can issue read commands).

[0052] In stage 305, one or more operations may be performed to identify valid data (e.g., TUs). Although a count of valid TUs in the block may be readily available (e.g., available to the controller), the location of each valid TU may be identified. In some instances, a range stream process 320 or a replay stream process 325 may be used to identify the location of valid TUs. The range stream process 320 may contain commands that process moving or copying the entire memory subsystem. Alternatively or concurrently, the replay stream process 325 may use a buffer (e.g., a read buffer 335) and may cycle through physical locations in the block.

[0053] In stage 310, one or more operations can be performed to read valid data (e.g., TUs) identified in 305. For example, after a valid TU is identified, the FLA corresponding to each valid TU can be compared with the entry held by scoreboard 302. If the FLA corresponding to the valid TU matches the FLA held by scoreboard 302, a read command associated with the valid TU can be issued. Conversely, if the FLA does not match, the entry held by scoreboard 302 can be released (e.g., moved to the end of the list). In other instances, if the FLA does not match, the system can be configured to continue looping through valid TUs until the FLA matches the entry held by scoreboard 302.

[0054] In stage 315, one or more operations may be performed to write the valid data (e.g., TU) read in stage 310. As discussed herein, when the FLA corresponding to the valid TU matches the FLA maintained by scoreboard 102, a read command associated with the valid TU is issued. Alternatively or additionally, based on the read command being issued, the data associated with the valid TU may be written (e.g., moved) to a destination block (e.g., to a destination address). Due to the use of a linked list, the data associated with the valid TU may be written sequentially to the destination block.

[0055] In stage 305, various methods can be used to determine valid data (e.g., valid TUs). For example, replay stream procedure 325 can support the determination of valid data by iterating through various TUs stored in a buffer (e.g., in read buffer 335). The buffer may contain one or more addresses (e.g., TUA and / or FLA) corresponding to locations in blocks from which the respective TUs are read. In some instances, replay stream procedure 325 may be selected based on one or more settings associated with a mode register and / or controller (e.g., memory subsystem controller, local media controller). That is, the use of replay stream procedure 325 may be optional. In some instances, replay stream procedure 325 may be performed in multiple stages (e.g., first stage 330 and second stage 340).

[0056] When using the replay stream process 325, the read buffer 335 may receive signal 371 during the first phase 330. Signal 371 may initiate the read buffer 335 to cycle through one or more TUs (e.g., as shown in 373). That is, the read buffer 335 may map (e.g., determine, identify, etc.) the TUA and FLA of potentially valid TUs according to the order in which read commands are issued. During the second phase 340, the TUA and FLA of each TU may be identified and provided to the scoreboard 302 (e.g., via signal 375 and / or signal 369). In some instances, the first phase 330 and the second phase 340 may be asynchronous (e.g., the duration may occur between the start of the first phase 330 and the completion of the second phase 340).

[0057] After identifying and providing the TUA and FLA to the scoreboard, a list (e.g., a linked list) can be compiled at scoreboard 302. In some instances, a lookup of the TUA and FLA can then be issued (e.g., at 350) to determine if the associated data remains valid, and if so, the valid data can be written to the destination block (e.g., sequentially). In some instances, lookup 350 can receive read responses occurring in sequence, and lookup 350 can be performed to determine if the TUA and FLA match the entries stored at scoreboard 302. Because the system can utilize a linked list, the TUA and FLA stored at scoreboard 302 can be compared with the corresponding TUA and FLA of each received read response (e.g., sequentially). Depending on the result of the comparison, a write command can be issued, and the TU can be written to the destination block. In some instances, TUs associated with the same codeword can be grouped together and written sequentially to the destination block.

[0058] The range flow procedure 320 may contain processing commands that fold data across the entire memory subsystem (e.g., move and organize data). For example, the range flow procedure 320 may be selected based on one or more settings associated with a mode register and / or controller (e.g., memory subsystem controller, local media controller). That is, the use of the range flow procedure 320 may be optional. In some instances, the range flow procedure 320 may include a request to indicate the start and end list of TUAs to be scanned. In some instances, when this request is made (i.e., recognized by the controller and / or host system), a flag is set to guide the firmware along the list of TUAs to be scanned.

[0059] When using range stream procedure 320, a read command can be issued for each FLA in a specific block. The corresponding TUA and FLA can be stored in scoreboard 302 as part of a list (e.g., a linked list). In some instances, a lookup of the TUA and FLA can then be issued (e.g., at 350) to determine if the associated data remains valid, and the valid data can be written (e.g., sequentially) to the destination block. Because the system can utilize the linked list, the identified TUA and FLA can be compared with the first entry in the list (e.g., the head of the list). Depending on the result of the comparison, a write command can be issued, and the TU can be written to the destination block. In some instances, TUs associated with the same codeword can be grouped together and written sequentially to the destination block.

[0060] In some instances, both the range stream process 320 and the replay stream process 325 may result in a lookup 350 to determine whether a read response (e.g., the TUA and FLA corresponding to the read response) matches an entry stored at scoreboard 302. Therefore, the TUA and FLA associated with the read response may be provided to scoreboard 302 via signal 381. Signal 381 may be transmitted to scoreboard 302 via a controller or other component. In some instances, signal 381 may be transmitted to scoreboard 302 at a first time (e.g., at 350; not shown), and the result of the comparison may be received at a second time (e.g., at 355, via signal 383). Therefore, in some instances, portions of the comparison may occur at stage 305 (e.g., during stage 305) and at stage 310 (e.g., during stage 310). In some instances, the operations performed at 350 and 355 may be asynchronous (e.g., a duration may occur between the operations performed by various components at 350 and 355).

[0061] Upon receiving a read response, the corresponding TUA and FLA can be compared with the first entry in the list stored at scoreboard 302 (e.g., the head of the list). In some instances, the TUA and FLA may not match the first entry. For example, a comparison of the first entry with the first received TUA and FLA may indicate that the entry does not match. In this instance, the first entry in the list can be released (e.g., moved to the bottom of the list). Therefore, the TUA and FLA can be compared with a subsequent entry (or more entries) in the list until a match is determined. Once a match is determined, a read of the associated TU can be published (e.g., at 360), and the TU can subsequently be written to the destination block (e.g., at 365, which may occur at stage 315). In some instances, stages 310 and 315 can be asynchronous (e.g., a duration may occur between the two stages).

[0062] According to some aspects, entries associated with the same codeword (or multiple codewords) can be grouped together in scoreboard 302. For example, entries associated with the same codeword can be grouped together in scoreboard 302 such that when written to a destination block (e.g., when a write command is issued), the entries remain associated with the same codeword at the destination block. That is, a write command can be issued for grouped entries such that valid TUs are written to the same codeword and the valid TUs are aligned with the codeword boundaries on the destination block. In some instances, to group entries in scoreboard 302, entries can be sorted using a sorting algorithm that groups TU entries based on the codeword size of the memory page at the destination block or based on the relative position of the TU relative to the source memory page (e.g., relative to the codeword boundaries on the source memory page). For example, a set of TUs of a given size (e.g., 4KB or 8KB) is selected for media management operations and sorted such that entries corresponding to said set of TUs are grouped together in scoreboard 302. By grouping entries corresponding to the set of TUs together in scoreboard 302, write commands can be issued sequentially (or according to some other order) for each entry in 302, such that the TU is written to the same codeword at the destination block (e.g., aligned with the codeword boundary). This technique allows data (e.g., TUs) previously stored within the same codeword (and therefore eligible for snapshot reads) to remain eligible for snapshot reads after media management operations (e.g., because the TU is written to the destination block at the same codeword or within the codeword boundary on the memory page of the destination block).

[0063] Figure 4 This is a block diagram 400 of an example scoreboard for performing snapshot read optimizations for media management of a memory subsystem, according to some examples of this disclosure. The media management operation describes a read sequence 405, a read response 410, and a write command 415. In some instances, the write command 415 may be based on the order of the read sequence 405 and the read response 410 during the media management operation. Alternatively or concurrently, a scoreboard 425 may be used to implement the media management operation, which may be as described in reference... Figure 3 An example of the scoreboard 302 described. In some instances, the scoreboard 425 may contain one or more scoreboard entries 420 to facilitate media management operations, for example, as referenced. Figure 3 The entry for scoreboard 302 is described.

[0064] In some instances, Figure 4 This describes the operations involved in media management. As discussed herein, media management operations can occur to migrate data from one location to another independently of any direct host system interaction. Figure 4In the context of this, each of the read sequence 405, read response 410, and write command 415 may be associated with a block (e.g., a data block). Each block may contain one or more pages capable of storing a limited amount of data. For example, each block may contain 32 pages, each capable of storing 4KB or 8KB of data (or other amounts of data). For illustrative purposes, each of the read sequence 405, read response 410, and write command 415 describes twelve (12) valid data blocks (numbered 1 to 12) and various blocks of dirty / expired data and / or erased data. Dirty data is the latest version of data in the cache that has not yet been saved to the media (e.g., NAND). Expired data contains data that was previously written but is no longer associated with a valid logical address, such as a logical address referenced by the host system (e.g., in a physical-to-logical (P2L) mapping table). Each valid data block (e.g., 1 to 12) may be a TU or may be referred to as a TU.

[0065] In some instances, each TU may be associated with one or more codewords (e.g., one of codewords 430 or 435). Each codeword may contain boundaries, and multiple TUs may reside within a single boundary. For example, such as Figure 4 As shown, the boundary of codeword 430 may include the first and second TUs. That is, the first and second TUs may be associated with the first codeword.

[0066] Range flow process (e.g., as referenced) Figure 3 The described range stream process 320) and / or replay stream process (e.g., as referenced) Figure 3 The described replay stream process 325 may be associated with the read sequence 405. For example, the range stream process and / or the replay stream process may issue one or more read commands to the TU for reading media management operations. Figure 4 As shown and for illustrative purposes only, read sequence 405 may issue one or more read commands for TUs 1 to 12. Read sequence 405 may issue read commands simultaneously, such that read commands for each subsequent TU are issued sequentially (i.e., read commands for each TU are issued consecutively). Read commands may be stored in scoreboard 425 as a list (e.g., a linked list, a tree circular buffer, or a tree). In some instances, the TUA and FLA associated with each TU may be stored in scoreboard 425 as scoreboard entries 420 (e.g., ...). Figure 3 In the scoreboard 302), entries with the same codeword can be grouped together by storing entries associated with each codeword. Therefore, when written to the destination block, entries can be associated with the same codeword.

[0067] In some instances, scoreboard entry 420 may store a corresponding value associated with each TU. Therefore, when an associated read response is received (i.e., a response associated with the TUA, FLA, and / or codeword stored in scoreboard 425), the corresponding value can be updated. Based on the values ​​stored in scoreboard entry 420, TUs can be written to the destination block sequentially. A list of potential states for a single scoreboard entry is shown below in Table 1.

[0068] value meaning 0 null 1 TUA / FLA pair found 2 A search request has been sent. 3 Received search response 4 Allocated buffer 5 Read request sent 6 Received read response 7 Write request sent

[0069] Table 1

[0070] As shown in Table 1, the scoreboard 425 may contain multiple entries. Each of the pages (and TUs 1 to 12) may be associated with a corresponding entry. For example, some pages (and TUs) may be associated with the same entry, and other pages (and TUs) may be associated with different entries. Each entry represents the current state of the corresponding page and / or TU.

[0071] In some instances, entry "0" indicates an empty state. An empty state can indicate that the page is empty (e.g., it has been previously erased) and no valid data will be read from the page and / or the page can be freely written to. In some instances, entry "1" indicates that TUA and FLA have been identified. In some instances, entry "2" indicates that a lookup has been performed on TUA and FLA to determine whether the associated data is still valid.

[0072] In some instances, entry "3" indicates a response regarding whether the data associated with TUA and FLA is valid. If the data is valid, the entry remains on the scoreboard. If the data is invalid, the entry can be moved to the end of the list and assigned "0". In some instances, entry "4" indicates that valid data is being allocated to the buffer (e.g., reference...). Figure 3 (Read buffer 335). In some instances, entry "5" indicates that valid data associated with TUA and FLA has been read.

[0073] In some instances, entry "6" indicates that valid data associated with TUA and FLA has been received. In some instances, entry "7" indicates that valid read data will be written. After data has been written, the entry can be assigned "0" and moved to the end of the list. This indicates that the data has been successfully (and sequentially) written back.

[0074] After the read sequence 405 is published, read responses 410 can be received out of order (e.g., at scoreboard 425). For example, as Figure 4As shown, each response may be received out of order or at least in a different order than the order in which the read sequence 405 was published. In some instances, valid data may be received out of order than the read sequence 405, and the received valid data may consist of one or more blocks of dirty and / or expired data, or both. Receiving the read response sequence 410 out of order can be attributed to a variety of reasons, including but not limited to the fact that a particular channel is temporarily used for different operations (e.g., for host read operations). If the read responses 410 are written to the destination block in the order they are received (i.e., out of order), the overall performance of the memory subsystem may be degraded. Therefore, as Figure 4 As shown, it may be beneficial to issue write command 415 based on determining the codeword boundaries associated with the identified entry.

[0075] Alternatively, one or more codewords (e.g., codeword 440) may not be mapped by the host device. For example, codeword 440 may become unmapped due to one or more errors during data movement or transfer (e.g., due to one or more commands from the host device), improper updates to the codeword mapping, which can cause data loss or other problems. In conventional memory systems, unmapped codewords (e.g., codeword 440) can be read (e.g., as part of read sequence 405) in a sequence different from the order in which read response 410 is received, and written (e.g., as part of write command 415) to the memory subsystem. After the write, the mapping of unmapped codeword 440 can be updated (e.g., in the P2L table), allowing the host to issue other access commands (e.g., read commands, write commands) to codeword 440. This also allows codeword 440 to be written to the destination block in an order that can utilize fast read operations, such as snapshot reads, thereby improving the overall performance of the memory subsystem.

[0076] To issue write command 415, aligning the TU with the codeword boundary, the entries associated with the corresponding TU can be maintained by scoreboard 425. As discussed herein, upon receiving read response 410, the entries can be sorted according to the position of the corresponding TU. For example, scoreboard 425 can be configured to sort each entry based on its relative position to the associated codeword or TU relative to the codeword boundary. For example, TUs “1” and “2” can be associated with codeword 435, and TUs “7” and “8” can be associated with codeword 430. After receiving read response 410, scoreboard 425 can be configured to sort each entry (e.g., entries “1”, “2”, “7”, and “8”) according to codewords 430 and 435. Because entries “1” and “2” are associated with codeword 435, and because entries “7” and “8” are associated with codeword 430, entries “1” and “2” can be grouped together, and entries “7” and “8” can be grouped together. In other words, write commands 415 associated with entries "1" and "2" can be issued, ensuring that the entries remain associated with the same codeword. Similarly, write commands 415 associated with entries "7" and "8" can be issued, ensuring that the entries remain associated with the same codeword. In the event that dirty and / or expired data is received between similarly grouped entries, the scoreboard can update the entries associated with each TU, rearranging valid data and / or dirty and / or expired data. Therefore, when write command 415 is issued, a TU can be written, such that each is associated with the same codeword in read sequence 405.

[0077] In some cases, when rearranging valid data and / or dirty and / or expired data, data can be inserted between TUs to ensure that (e.g., a given size) a group of TUs is associated with (e.g., a given size) the same codeword. For example, invalid data, data not associated with read operations, etc., can be inserted to ensure that each TU remains associated with the same codeword when written to the destination block. Alternatively, data that meets the conditions for a snapshot read before garbage collection (e.g., because the data is associated with the same codeword) can remain eligible for a snapshot read after collection. For example, entries in scoreboard 425 can be sorted such that TUs stored at the source location and spanning multiple codewords can be grouped together, and a write command 415 can be issued at the destination location to write TUs to the same codeword (e.g., within codeword boundaries).

[0078] Figure 5 This describes an instance machine of a computer system 500 optimized for snapshot reading, based on the examples disclosed herein, supporting a set of media management operations. The computer system 500 may contain an instruction set for causing the machine to perform any one or more of the techniques described herein. In some instances, the computer system 500 may correspond to a host system (e.g., reference...). Figure 1The host system 105 described includes a memory subsystem (e.g., reference 105). Figure 1 The memory subsystem 110 described herein, coupled to or utilizing the memory subsystem, or may be used to perform controller operations (e.g., execute an operating system to perform operations corresponding to the reference). Figure 1 The operation of the codeword manager 150 is described. In some instances, the machine can connect to (e.g., network) other machines on a local area network (LAN), intranet, extranet, and / or the Internet. The machine can operate as a peer machine in a peer-to-peer (or distributed) network environment or as a server or client machine in a cloud computing infrastructure or environment, or within the capacity of a server or client machine in a client-server network environment.

[0079] A machine can be a personal computer (PC), a tablet PC, a set-top box (STB), a personal digital assistant (PDA), a cellular telephone, a network appliance, a server, a network router, a switch or bridge, or any machine capable of executing (sequentially or otherwise) a set of instructions specifying actions to be taken by said machine. Furthermore, while a single machine is shown, the term "machine" can also include any collection of machines that individually or collectively execute a set of instructions (or multiple sets of instructions) to perform any of the methods discussed herein.

[0080] The example computer system 500 may include a processing device 505, a main memory 510 (e.g., ROM, flash memory, DRAM such as synchronous DRAM (SDRAM) or Rambus DRAM (RDRAM), a static memory 515 (e.g., flash memory, static RAM (SRAM), etc.), and a data storage system 525, which communicate with each other via a bus 545.

[0081] Processing device 505 represents one or more general-purpose processing devices, such as microprocessors, central processing units, 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 implementing other instruction sets, or a combination of instruction sets. Processing device 505 may also be one or more special-purpose processing devices, such as ASICs, FPGAs, DSPs, network processors, etc. Processing device 505 is configured to execute instructions 535 for performing the operations and steps discussed herein. Computer system 500 may further include a network interface device 520 for communication on network 540.

[0082] Data storage system 525 may include machine-readable storage medium 530 (also called computer-readable medium) storing one or more sets of instructions 535 or software embodying any one or more methods or functions described herein. Instructions 535 may also reside wholly or at least partially in main memory 510 and / or processing device 505 during execution by computer system 500, which also constitute machine-readable storage medium. Machine-readable storage medium 530, data storage system 525, and / or main memory 510 may correspond to a memory subsystem.

[0083] In one instance, instruction 535 includes instructions for implementing a codeword manager 550 (e.g., reference...). Figure 1 The described codeword manager 150) provides functional instructions. Although the machine-readable storage medium 530 is shown as a single medium, the term "machine-readable storage medium" can include a single medium or multiple media storing one or more sets of instructions. The term "machine-readable storage medium" can also include any medium capable of storing or encoding a set of instructions executable by a machine and causing the machine to perform any one or more of the methods disclosed herein. The term "machine-readable storage medium" can include, but is not limited to, solid-state memory, optical media, and magnetic media.

[0084] Some parts of the previously described description have been presented with respect to the algorithms and symbolic representations of operations on data bits within computer memory. These algorithmic descriptions and representations are the means by which those skilled in the art of data processing most effectively communicate the essence of their work to others skilled in the art. Algorithms are, and are generally considered, a self-consistent sequence of operations that produce a desired result. An operation is one that requires physical control over physical quantities. These quantities are usually, but not necessarily, in the form of electrical or magnetic signals that can be stored, combined, compared, and otherwise controlled. Sometimes, primarily for general reasons, it has proven convenient to refer to these signals as bits, values, elements, symbols, characters, terms, numbers, or the like.

[0085] However, it should be remembered that all such terms and similar terms should be associated with appropriate physical quantities and are merely convenient labels applied to those quantities. This disclosure may refer to the actions and processes of a computer system or similar electronic computing device that control and transform data represented as physical (electronic) quantities in the registers and memories of a computer system, or other data similarly represented as physical quantities in the computer system's memory or registers or other such information storage systems.

[0086] This disclosure also relates to an apparatus for performing the operations described herein. This apparatus may be specifically configured for a desired purpose, or may comprise a general-purpose computer selectively activated or reconfigured by a computer program stored in a computer. This computer program may be stored in a computer-readable storage medium, such as, but not limited to, any type of disk, including floppy disks, optical disks, CD-ROMs and magneto-optical disks, ROMs, RAMs, EPROMs, EEPROMs, magnetic cards or optical cards, or any type of media suitable for storing electronic instructions and each coupled to a computer system bus.

[0087] The algorithms and displays presented herein are not inherently related to any particular computer or other device. Various general-purpose systems can be used with the programs taught herein, or it may be convenient to construct more specialized devices for performing the methods. The structures of various such systems will be presented as described below. Furthermore, this disclosure is described without reference to any particular programming language. It should be understood that the teachings of this disclosure as described herein can be implemented using various programming languages.

[0088] This disclosure may be provided as a computer program product or software, which may include a machine-readable medium having instructions stored thereon that can be used to program a computer system (or other electronic device) to perform processes according to this disclosure. Machine-readable media includes any mechanism for storing information in a machine-readable (e.g., computer-readable) form. In some instances, machine-readable (e.g., computer-readable) media includes machine-readable storage media such as ROM, RAM, disk storage media, optical storage media, flash memory components, etc.

[0089] In the foregoing description, examples of this disclosure have been described with reference to specific instances thereof. It will be apparent that various modifications may be made thereto without departing from the broader spirit and scope of the embodiments of this disclosure set forth in the appended claims. Therefore, the description and drawings should be viewed in an illustrative rather than restrictive sense.

Claims

1. A method for memory operations, comprising: Store multiple entries associated with a set of media management operations for multiple delivery units, wherein the multiple entries include location information for the multiple delivery units; The destination location of the delivery unit associated with the set of media management operations is determined at least in part based on codeword boundary alignment, such that the delivery unit is aligned with the codeword boundary on the memory page, wherein the codeword boundary is associated with one or more delivery units that include at least the delivery unit. and At least in part, based on determining the destination location of the delivery unit associated with the set of media management operations, a write command associated with the set of media management operations is issued, wherein the write command includes an instruction to write the delivery unit to the destination location.

2. The method according to claim 1, further comprising: The plurality of entries are sorted at least in part based on the destination location of the transmission unit, wherein the destination location is determined at least in part based on the sorting of the plurality of entries.

3. The method according to claim 2, further comprising: The multiple entries are sorted such that the entries corresponding to subsets of the multiple transmission units are consecutive.

4. The method of claim 1, wherein the data size corresponding to the transmission unit is the same as the codeword size associated with the codeword boundary on the memory page.

5. The method of claim 1, further comprising: After the write command is issued, the read operation of the transmission unit is performed.

6. The method of claim 1, further comprising: The destination location of the second transfer unit is determined such that the second transfer unit is aligned with the boundary of the second codeword on the memory page, and the second transfer unit does not overlap with the first transfer unit.

7. A method for memory operations, comprising: Store multiple entries associated with a set of media management operations for multiple delivery units, wherein the multiple entries include location information for the multiple delivery units; The destination location of the delivery unit associated with the set of media management operations is determined at least in part based on codeword boundary alignment, such that the delivery unit is aligned with the codeword boundary on the memory page, wherein the codeword boundary is associated with one or more delivery units that include at least the delivery unit. The plurality of entries are sorted according to a sorting algorithm, which groups the entries of a subset of the plurality of transmission units at least in part based on the codeword size of the memory page, wherein the plurality of entries are sorted at least in part based on the destination location of the transmission unit, and wherein the destination location is determined at least in part based on the sorting of the plurality of entries. and At least in part, based on determining the destination location of the delivery unit associated with the set of media management operations, a write command associated with the set of media management operations is issued, wherein the write command includes an instruction to write the delivery unit to the destination location.

8. The method of claim 7, wherein each of the subsets of the plurality of transmission units corresponds to the codeword size.

9. A device for performing memory operations, comprising: Multiple memory devices; and A controller, coupled to the plurality of memory devices, wherein the controller is operable to cause the devices to: Store multiple entries associated with a set of media management operations for multiple delivery units, wherein the multiple entries include location information for the multiple delivery units; The destination location of the delivery unit associated with the set of media management operations is determined at least in part based on codeword boundary alignment, such that the delivery unit is aligned with the codeword boundary on the memory page, wherein the codeword boundary is associated with one or more delivery units that include at least the delivery unit. and At least in part, based on determining the destination location of the delivery unit associated with the set of media management operations, a write command associated with the set of media management operations is issued, wherein the write command includes an instruction to write the delivery unit to the destination location.

10. The device of claim 9, wherein the controller is operable to cause the device to: The plurality of entries are sorted at least in part based on the destination location of the transmission unit, wherein the destination location is determined at least in part based on the sorting of the plurality of entries.

11. The device of claim 10, wherein the controller is operable to cause the device to: The multiple entries are sorted such that the entries corresponding to subsets of the multiple transmission units are consecutive.

12. The device of claim 9, wherein the data size corresponding to the transmission unit is the same as the codeword size associated with the codeword boundary on the memory page.

13. The device of claim 9, wherein the controller is operable to cause the device to: After the write command is issued, the read operation of the transmission unit is performed.

14. The device of claim 9, wherein the controller is operable to cause the device to: The destination location of the second transfer unit is determined such that the second transfer unit is aligned with the boundary of the second codeword on the memory page, and the second transfer unit does not overlap with the first transfer unit.

15. A device for performing memory operations, comprising: Multiple memory devices; and A controller, coupled to the plurality of memory devices, wherein the controller is operable to cause the devices to: Store multiple entries associated with a set of media management operations for multiple delivery units, wherein the multiple entries include location information for the multiple delivery units; The destination location of the delivery unit associated with the set of media management operations is determined at least in part based on codeword boundary alignment, such that the delivery unit is aligned with the codeword boundary on the memory page, wherein the codeword boundary is associated with one or more delivery units that include at least the delivery unit. The plurality of entries are sorted according to a sorting algorithm, which groups the entries of a subset of the plurality of transmission units at least in part based on the codeword size of the memory page, wherein the plurality of entries are sorted at least in part based on the destination location of the transmission unit, and wherein the destination location is determined at least in part based on the sorting of the plurality of entries. and At least in part, based on determining the destination location of the delivery unit associated with the set of media management operations, a write command associated with the set of media management operations is issued, wherein the write command includes an instruction to write the delivery unit to the destination location.

16. The apparatus of claim 15, wherein each of the subsets of the plurality of transmission units corresponds to the codeword size.

17. A non-transitory computer-readable storage medium comprising instructions that, when executed by a processing device, cause the processing device to perform the following operations: Store multiple entries associated with a set of media management operations for multiple delivery units, wherein the multiple entries include location information for the multiple delivery units; The destination location of the delivery unit associated with the set of media management operations is determined at least in part based on codeword boundary alignment, such that the delivery unit is aligned with the codeword boundary on the memory page, wherein the codeword boundary is associated with one or more delivery units that include at least the delivery unit. and At least in part, based on determining the destination location of the delivery unit associated with the set of media management operations, a write command associated with the set of media management operations is issued, wherein the write command includes an instruction to write the delivery unit to the destination location.

18. The non-transitory computer-readable storage medium of claim 17, wherein the processing means is further configured to: The plurality of entries are sorted at least in part based on the destination location of the transmission unit, wherein the destination location is determined at least in part based on the sorting of the plurality of entries.

19. The non-transitory computer-readable storage medium of claim 18, wherein the processing means is further configured to: The multiple entries are sorted such that the entries corresponding to subsets of the multiple transmission units are consecutive.

20. A non-transitory computer-readable storage medium comprising instructions that, when executed by a processing device, cause the processing device to perform the following operations: Store multiple entries associated with a set of media management operations for multiple delivery units, wherein the multiple entries include location information for the multiple delivery units; The destination location of the delivery unit associated with the set of media management operations is determined at least in part based on codeword boundary alignment, such that the delivery unit is aligned with the codeword boundary on the memory page, wherein the codeword boundary is associated with one or more delivery units that include at least the delivery unit. The plurality of entries are sorted according to a sorting algorithm, which groups the entries of a subset of the plurality of transmission units at least in part based on the codeword size of the memory page, wherein the plurality of entries are sorted at least in part based on the destination location of the transmission unit, and wherein the destination location is determined at least in part based on the sorting of the plurality of entries. and At least in part, based on determining the destination location of the delivery unit associated with the set of media management operations, a write command associated with the set of media management operations is issued, wherein the write command includes an instruction to write the delivery unit to the destination location.

Images