TW200842577A - System for block relinking - Google Patents

System for block relinking

Info

Publication number
TW200842577A
TW200842577A TW96150023A TW96150023A TW200842577A TW 200842577 A TW200842577 A TW 200842577A TW 96150023 A TW96150023 A TW 96150023A TW 96150023 A TW96150023 A TW 96150023A TW 200842577 A TW200842577 A TW 200842577A
Authority
TW
Taiwan
Prior art keywords
block
metablock
memory
update
write
Prior art date
Application number
TW96150023A
Other languages
Chinese (zh)
Inventor
Andrew Tomlin
Sergey Anatolievich Gorobets
Shai Traister
Original Assignee
Sandisk Corp
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date
Priority to US11/648,487 priority Critical patent/US20080162612A1/en
Priority to US11/647,906 priority patent/US20080162787A1/en
Application filed by Sandisk Corp filed Critical Sandisk Corp
Publication of TW200842577A publication Critical patent/TW200842577A/en

Links

Classifications

    • GPHYSICS
    • G06COMPUTING; CALCULATING; COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F12/00Accessing, addressing or allocating within memory systems or architectures
    • G06F12/02Addressing or allocation; Relocation
    • G06F12/0223User address space allocation, e.g. contiguous or non contiguous base addressing
    • G06F12/023Free address space management
    • G06F12/0238Memory management in non-volatile memory, e.g. resistive RAM or ferroelectric memory
    • G06F12/0246Memory management in non-volatile memory, e.g. resistive RAM or ferroelectric memory in block erasable memory, e.g. flash memory

Abstract

In accordance with various embodiments of the present invention, a system for block relinking during garbage collection is described. The system may include a non-volatile memory storage system including a memory configured to store a storage system firmware, a non-volatile memory cell array configured to maintain a first metablock, the first metablock comprising a block of the first metablock, and a processor in communication with the memory and the non-volatile memory cell array, the processor being configured to execute the storage system firmware stored in the memory, the storage system firmware comprising program instructions for writing a memory write to update a block of a first metablock to a block of a second metablock, copying valid portions of the block of the first metablock to the block of the second metablock, and linking the block of the second metablock to the first metablock.

Description

200842577 IX. Description of the Invention: TECHNICAL FIELD OF THE INVENTION The present invention relates generally to memory operations and, more particularly, to methods and systems for performing block re-linking. [Prior Art] Ο In a non-volatile memory system, waste is collected periodically (that is, combined (4)) into a data block stored in a memory to recover the storage capacity of the memory. In a typical waste collection operation, valid data from the block is copied to the other block. After the valid data has been transferred, the original block is erased to provide storage capacity. Currently, a write operation can trigger the memory system to perform a garbage collection operation. The host allows a fixed amount of time to perform write: operations and garbage collection operations. For example, a secure digital agreement limits time to 250 home seconds. If the printing bridge does not exceed the fixed date or interval in the write operation, a timeout error can be generated. The large P m ^ of the memory block is small due to the increased capacity, and the higher parallelism increases with the second. Therefore, as more information is transferred, it is written:: Execution and execution of the waste collection operation 2:::=:=r Set a _ to the amount of time; :::::Receive:::: The amount of time is over-the amount of time used for the collection operation. m is to be reduced by the waste material [Summary of the Invention] Various embodiments of the present invention are directed to the party of the chain, "the method and/or system for executing the block during collection. It should be understood that the embodiments can be implemented in a number of ways (including being implemented as a method, circuit, system, or device). Several embodiments of the invention are described below. In accordance with various embodiments of the present invention, a system for block re-chaining is described. The system can include a non-volatile memory storage system including: a memory configured to store a storage system firmware; a non-volatile memory unit array, the group The processor can be configured to execute a memory stored in the memory by a processor that is in communication with the non-volatile memory single a array. Storing the system firmware, the memory system includes a program instruction for writing a human-memory write to update a block of a first metablock to a second metablock-block, Copying the valid portion of the block of the first metablock to the block of the second metablock, and linking the block of the second metablock to the first metablock. Other embodiments and advantages of the present invention will be apparent from the following detailed description. [Embodiment] A detailed description of one or more embodiments is provided below in conjunction with the accompanying drawings. The descriptions of the two are provided in connection with the embodiments, but are not limited to any of the specific examples, and may be limited only by the scope of the patent application and encompass many alternatives, modifications, and equivalents. In the following description, numerous specific details are set forth to provide a thorough understanding. These details are provided for the purpose of example, and may be implemented in accordance with the scope of the patent application without any or all such specific details. For clarity, the description has not been unnecessarily obscured by the fact that the material (4), which is known to us in the technical field related to the embodiments of the 127724.doc 200842577, is not described in detail. Embodiments described herein provide methods and/or systems for performing partial waste collection, including block re-linking. Typically, the memory is updated during the waste collection period. This memory update can be performed using a newer metablock that is used to update the original metablock. Between the garbage collections, the valid portion of the block having the original metablock (i.e., the portion that has not been updated) is copied into the block having the updated metablock. The remaining portion of the updated meta-block can then be de-duplicated from the remaining portion of the updated meta-block, and the block having the original meta-block can be de-coupled from the remainder of the original meta-block. The block with the updated metablock can then be linked to the remainder of the original metablock. Non-volatile memory storage system Figure! A simplified block diagram of an example of a non-volatile memory storage system in accordance with the present invention. - Host systems (eg, desktops, audio players, digital cameras, and other computing devices) can write data to the non-volatile memory storage system 1G2 and can be read from the non-volatile memory storage system H) 2 Take the information. The non-volatile memory storage system 1〇2 can be incorporated into the host or removably connected to the host. As shown in FIG. 2, the non-volatile memory storage system 1G2 includes a memory controller 110 in communication with the memory 118. Typically, the book memory controller 110 controls the operation of the memory 118. Examples of operations include writing (or stylizing) data, reading data, erasing data, verifying data, working on waste collection operations, and other operations. The memory control 11G includes an 11-row row 124, the bus bar 124 is interfaced with the system bus 126 via a host interface (10), and the memory controller is interfaced with the memory 118 via the memory 127724.doc 200842577 interface 108. . The communication with the bus bar 124 includes a host interface 104, a processor 106 (eg, a microprocessor, a microcontroller, and other processors), a memory interface 108, a random access memory (Ram) 112, and an error correction code (ECC). Circuit 114 and read only memory (R〇M) 116. The R〇M 116 can store a storage system firmware that includes program instructions for controlling the operation of the memory 118. The processor 〇6 is configured to execute program instructions loaded from the ROM 116. The storage system firmware can be temporarily loaded into the RAM 112, and in addition, RAM can be used to buffer the data transferred between the host and the memory 118. The ECC circuit 114 can check for errors in the memory controller u〇 between the host and the memory 118. If an error is found, the ECC circuit 114 can correct a certain number of error bits, depending on the E C C algorithm used. Memory 118 may include array logic 12A and non-volatile memory cell array 122. The non-volatile memory cell array 122 can include a variety of non-volatile memory structures and techniques. Examples of non-volatile memory technologies include flash memory (eg, NAND, NOR, multi-level cell (MLC), split bit line NOR (DINOR), AND, high capacitance coupling ratio (HiCR), asymmetric contactless Transistor (ACT), other flash memory), erasable programmable read only memory (EPROM), electrically erasable programmable read only memory (EEPROM), one-time programmable (〇τρ) memory And other memory technologies. The array logic 120 interfaces the memory controller to the non-volatile memory cell array 122 and provides, for example, addressing, data transfer and sensing, and other support to the non-volatile memory cell array and memory. Body cell array 127724.doc 200842577 彳 To support non-volatile memory cell array l22, array logic can include column decoder, row depletion device, charge pump, word line electric castle generator, page buffer, input/output buffer , address buffers and other circuits.

C Figure 2 is a simplified block diagram of the organization of the D-invisible early-arc array in the plane. One or more memory cell arrays can be divided into multiple planes or sub-arrays. In the example of Fig. 2, a memory cell array is divided into four planes 202 to 205. It should be appreciated that other numbers of planes (such as 丨, 2, 8, μ, more) may be present in the non-volatile memory storage system. Yes: 2G2 2G3, 2G4 or 2G5 per plane is divided into several 5 仏 单元 unit blocks (such as blocks to 2 a and Μ. to 223) located in the respective planes 2〇2 to 05. - The minimum number of memory cells that can be physically erased together. In order to increase the parallelism, the blocks can be operated in a larger block unit, wherein one block from each plane, 2〇3, 2G4 or 2〇5 is logically linked together to form a unitary block. . For example, four blocks 2Π) to 213 can be logically linked to form a__. Furthermore, the blocks used to form the - metablocks may come from various locations within their respective planes, such as planes 2〇2 through 205. For example, four blocks 22A through 223 from respective locations within the 205 can be logically chained together to form a further metablock. The metablock may extend across all four logical planes 2〇2 to 2〇5 in the non-volatile memory storage system, or the non-volatile memory storage system may be from one or more of one or more different planes The block dynamically forms a metablock. The metablocks can be constructed from blocks in one or more of the dies and/or different planes on the wafer. According to the "embodiment", a logical bond between blocks for forming a unitary block (for example, a region 127724.doc -10- 200842577 block 2 2 0 to 2 3 0 ) can be stored in a data structure (such as a bar) Block key table). For example, the 'block bonding table' may refer to the spear blocks 220 221, 222, and 223 being chained together to form a unitary block. As discussed further below, several blocks of a unitary block can be uncoupled and other blocks can be associated with a unitary block. Block 220 may be decoupled from the metablock (i.e., removed) and a block 224 may then be associated with the metablock. The block link table can describe a block including blocks 224, 221, 222, and 223. This process can often be referred to as "re-linking." According to an embodiment, increased read and/or write parallelism can be achieved by constructing metablocks from blocks located in different dies and/or wafers. Figure 3 is a simplified block diagram of a page of memory cells. Each block (such as blocks 210 to 213) is further divided into pages of memory cells. As shown in Fig. 3, each block 210, 211, 212 or 213 is divided into eight pages P0 to P7. Alternatively, there may be pages of 16, 32 or more memory cells within each block 21, 211, 212 or 213. To increase the operational parallelism of a non-volatile memory storage system, pages within two or more blocks can be logically linked into a meta page. For example, the meta page may be formed by one page (such as ρι) from each of the four blocks 210 to 213. The 兀 page may extend across all planes in the non-volatile memory storage system or "Hai non-volatile memory storage system may be one or more of one or more independent blocks in one or more different planes The page dynamically forms a meta page. Figure 4 is a simplified block diagram of the sectors of the mouth and body. A page can be further divided into - or multiple sectors. The amount of data in each page can be an integer 127724.doc -11 - 200842577 One or more data sectors' Each of which can store 512 bytes of data. Figure 4 shows page 401 divided into two sectors 4〇2 and 4〇4. Each sector 402 or 404 contains data 4〇6 (which may be 512 bytes in size) and additional item information 4〇5 associated with the material. The additional item data 405 can be 16 bytes in size and can store, for example, an ECC calculated from the data 406 during stylization, a logical address associated with the data, a block erased, and re-created. The count of the number of stylizations, the control flag, the operating voltage level, and other information associated with the data. Figure 5 is a simplified block diagram of a logical interface between a host and a non-volatile memory storage system. A contiguous logical address space 512 provides an address for the data that can be stored in the memory. The logical address space 512 as viewed by the host can be divided into increments of data clusters. Each cluster may include a certain number of data sectors (such as 4 sectors to 64 sectors). As shown in Figure 5, an application executing on the host generates three data files 1, 2 and 3. Files 1, 2 and 3 can be an ordered set of data and are identified by a unique name or other reference. The host assigns a logical address space that has not been set to another broadcast to file 1. Here, the file is shown as having been assigned a continuous range of available logical addresses. § When the host generates file 2 after file 1, the host similarly assigns two different ranges of consecutive addresses within the logical address space 5 12 . The host may not assign consecutive logical addresses to a file (such as archives 1, 2, or 3), but instead may assign segments of logical addresses between logical address ranges that have been configured for other archives. The example of Figure 5 shows another file 3 configured with other portions of logical address space 512 that were not previously configured for broadcasts 1 and 2 and other materials. 127724.doc -12- 200842577 The host can track the logical address space 512 ' by the maintenance of a file configuration table (FAT), where the logical address assigned by the host to each data broadcast (such as broadcasts 1 to 3) is used by The conversion is maintained. The host reference file (1) is not based on its logical address and is not a non-broadcast 3. The physical location of the file is stored according to the non-volatile memory system. In addition, the non-volatile memory storage system reference files 1 to 3 are based on the logical address of the data that has been written and are not referenced according to the logical address assigned to the file. The non-volatile memory storage money is converted by the logical address provided by the host to a unique physical address stored in the memory cell array 5〇2 of the lean material from the host. Block Table π is a table of these logical-to-physical address translations maintained by a non-volatile LV memory system. Staged Waste Collection Figure 6 is a flow diagram of a prior art for a staged waste collection operation in accordance with one embodiment of the present invention. As described herein, certain embodiments may perform re-linking during the knife P "reusable waste collection. It will be appreciated that when the original stored bedding becomes obsolete, the information stored at a particular host logical address may be covered by the new shell material. Write. In response, the 'non-volatile memory storage system writes the new material into the update block, and then changes the memory to the body address table for the logical address of 4 pics to identify the new data. New physical block. Then erase the blocks containing the original data at their logical addresses and make them available for storing additional data (except when using - or other - writes to the It body). This erasure occurs before, during, or after a write operation, and the result is that the data stored at a given logical address has been written to the same logical address after the new material has been written to the same logical address. The host makes 127724.doc 200842577 obsolete or invalid. Many memory blocks can store invalid data for a certain period of time. The size of blocks and metablocks increases and these increases result in a larger proportion of individual data writes. The data is written to a quantity of less than one block of storage and, in many instances, even less than a block of storage capacity. The non-volatile memory storage system can direct new data to an erased state. The pool element block, so this boot can produce unfilled blocks or metablocks

C points. If the new data is an update of some of the data stored in another block, then the remaining valid element pages of the data from other blocks (with logical addresses adjacent to the logical address of the new data element page) are also logical. The address order is copied to the new metablock. Old metablocks can hold other valid material metapages. Therefore, the material of some meta-pages of a different metablock can be made obsolete or invalid, and replaced by new data having the same logical address written to a different metablock. In order to maintain sufficient physical memory (4) to store data in the logical address space, the material may be periodically collected (i.e., compressed or merged). Typically, the waste collection operation involves reading the valid data from the block and writing the valid data to the new block, ignoring the invalid data in the process. The volatile memory storage system can be in the timeout period configured for the writer command. Perform a waste collection operation. According to an embodiment of the invention, if the receiving operation cannot be completed within the timeout period, the waste collection can be made into eight different stages (or portions). Here, the non-volatile memory system uses the timeout period configured for multiple write commands, and the sub-header is used to perform the waste collection operation. In other words, the non-volatile memory storage system utilizes 127724.doc -14- 200842577 for multiple dry sections. Write the command's timeout period to perform a waste collection operation; if the second =) receive, write-memory write receive will be written to the record from the write command cycle To complete the write: Let it;:: Write: Command Configuration - Overwrite Write command can have a confession. According to the embodiment, - multiple fan timeout periods. The time period of the shift of the shifter, the r-sector (or other data block) is configured for the coffee officer, and one instance of the timeout period is 25 milliseconds. The area writes a single entry command or a multi-sector write command. In a single fan

The new data is written as a single sector into the human k-machine address. When a logical storage system having an LBA " face is used, for example, in a multi-sector write command, a plurality of sectors having new data adjacent to the local address are written to the memory. : As shown in operation 604, if a waste collection operation cannot be completed in the timeout period, the first stage of the garbage collection operation is performed within a timeout period configured for the write command. The remaining stages of waste collection can be completed in a later overdue cycle. By way of example, FIG. 7 shows a simplified block diagram of one example of a waste collection operation split into multiple stages 780 and 781 in accordance with one embodiment of the present invention. # Figure 7, the non-volatile memory storage system receives the multi-sector write command 704 and then receives a plurality of new data sectors 76A through 762 for storage into the memory. After receiving each data sector 76〇, 761 or 762, the busy signal 702 is issued to notify the memory host of more than 127724.doc -15- 200842577 Ο

Time period. The non-volatile memory storage system issues a busy signal 7〇2 to allow a write command (eg, a single sector or other saponin of the memory bank), which may include a waste collection operation (if Required) and other operations = When issuing the busy signal 7〇2, the host does not use another command or additional two tables to: non-volatile memory storage system. Non-volatile memory storage system, first The busy signal 7〇2 can be issued for a limited amount of time after receiving each data sector 76〇, 761 or 762 because the host allows a limited amount of solid time (ie, 'timeout period 750 to 752') Used to execute a write command. The right busy signal remains valid for a period longer than the timeout period of 75 〇, 751, or 752. The host can repeat the write command or terminate the process. Therefore, the non-volatile memory system It is not possible to issue the busy signal 7〇2 in a time greater than the timeout period of 75Q, π or 。. The busy signal is issued after the completion of writing multiple data sectors. 〇2 allows the host and the non-volatile memory storage system. Further communication. Look at Figure 7, available in multiple timeouts During the period from 75 〇 to 2, the waste is arranged, and the stages are 78G and 781. In other words, the non-volatile memory storage system: using each of the overtime periods of 75 (), 75_52 to perform - waste collection operation 2 each stage Or Chuan. For example, in the first timeout period 750 main execution - the first stage of waste collection. Here, the part of the valid data - part of the self - area during the first day of the second period of 7 5 〇 The block copy to another & block 2 continues at the first timeout period at the second timeout period 751 = the first waste collection operation. The non-volatile memory storage system performs the previous waste during the timeout period 751 The second phase of the collection operation is completed until the previous waste collection. The previous waste collection can be accomplished by copying the remainder of the valid data or the last ^ 127724.doc -16 - 200842577 self-block to another block. The decontamination collection operation cannot be completed in item (4) 751. 1 Non-volatile § Remembrance storage system can use the subsequent overdue period (such as the third timeout period 752) to complete the waste collection operation. 4 multi-sector writer command At the end of the state, non-volatile notes The memory storage system may issue the busy signal 702 after receiving the stop command or until all of the data 76(1) 62 has been written to the memory cell array.

Returning to Figure 6 'after performing one of the waste collection operations in a timeout period, 'in a memory bank (eg, a separate buffer block, a high speed temporary block) in operation 6G6 Buffer new data received from the write operation. Re-Linking Metablocks Figures 8A-8B illustrate block re-linking when an updated metablock is used to update-original metablocks, according to an embodiment. 8 includes an original metablock 8 of a plurality of individual blocks 802a through 802d; and an updated metablock 82 of a memory write 824, the memory write 824 can be included in the block New information in 822a. The original metablock is the block in which the data is being stored and is being updated. When new data received by the host is written to the update metablock, portions of the original metablock may become invalid. The update metablock 82A also includes blocks 822b through 822d which, as shown here, are empty from several to 822d. When a write-write command is received, the configuration-update block is included; the update block includes new material that invalidates portions of the original metablock. It should be understood that four blocks are shown in each metablock for convenience and clarity; a single block may contain any number of blocks suitable for a particular application. According to an implementation 127724.doc • 17- 200842577, the data sectors can be cleared across blocks 822a through 822d. As described above, a block chain table can be used to describe a metablock. The block link table may include an entry block 8〇仏 to 8〇2d containing the original meta block 8〇〇 and blocks 822a to 822d containing the update element block 82〇. According to an embodiment, when the original metablock 8〇〇 and the updated metablock 82〇 are re-linked, the entries in the 'block link table may be changed to reflect the re-link. Update metablock 820 includes memory write 824. The memory write 824 can be a memory write received from a write command (which can be a single sector write). Or 'block 822a' may include a multi-sector write that updates the original metablock 8〇0. The memory is written to 824 to update one of the blocks 8〇2a. The active portion of block 802a during the garbage collection period (i.e., the portion not updated by memory write 824) is copied into block 822a. Figure 8B illustrates the original metablock 80A, which is re-chained from the unaltered blocks 8〇2b to 802d of the original metablock 800 and the garbage collection block 822a of the update metablock 820. The knot of the knot. As shown in Figure 8B, block 822a includes a memory write 824 and an active portion of block 8 〇 2 & The block 802a is de-engaged from the original metablock 800 and the block 822& is uncoupled from the update block 820. Block 822a may be referred to as, after the relationship is removed, the block. The block that has been unlinked can be a block that has been removed or unlinked from the unary block. The garbage collection block 822 & is then re-linked with the remainder of the original metablock 8 〇 0 (i.e., blocks 8 〇 2b, 802c, and 802d) to form a re-linked original block 800. Several scenarios of staged waste collection using block re-linking are described with respect to Figures 15 through 18. For example, block re-linking can be used in conjunction with staged waste collection 127724.doc -18- 200842577 to reduce the time required to transfer data from the original metablock to the updated metablock. 'However, it should be understood that block re-linking can be used independently of the waste collection operation. When performing waste collection, the worst case (ie, the longest time it takes to complete the waste collection) can be given by equation (1): = ^Pages,block ^Txfer -Npages/bl〇ck,Nparallelism ^Terase (!) The center is used for the time of waste collection, the time used for stylization - the time of the page is used to transfer the time of the _ data page, and the kiss is the page in the block (4), for example, 32) _ The number of physical blocks that are parallelized and erased (eg, the number of blocks in the unary block), and is used to erase the time. Using the process described with respect to Figures 8A and 8B, The original metablock 8 is updated with the unupdated blocks 802b to 8〇2d copied. In this way, the worst case time for the garbage collection for the update of the original metablock 800 is now:

= Tprog *Npageslbl〇ck -f Txfer *Npages/bl〇ck + Trelmh + Terase (2) where 7Vw/m is used to re-link the unary block. As can be seen, there is no factor in equation (2). According to an embodiment, the re-link time may include a block erase time and a control update time. If waste collection is completed in less than a single timeout period (for example, less than 25 〇 ms), waste collection can be performed without stages. Alternatively, as described with respect to Figures 6 and 7, the waste collection can be split into two or more stages, and this process can be used without encountering the timeout error 127724.doc -19- 200842577 Allow longer waste collection. Figure 9 is a flow diagram depicting a process for chaining-stacking in a waste according to an embodiment. Process 9::: Update the write command of the original metablock, and include (4) the write command to re-link a block set of the update. Another memory of the original mortal block is written to trigger the scrap collection.

(4) Description—Used to perform a re-linking process while copying data that can contain waste collection operations/knife. According to each of the two cases, the waste collection can be used as a part of the memory-writing sequence: 仃. Figures 15 and 16 include flow diagrams depicting various situations in which staged waste collection occurs during a memory write sequence. In Z operation 9.2, a write command is received, the write command including a memory write for the first block (e.g., block 802a) of the original 7L block (e.g., the original metablock 8A). In. The memory write can be, for example, a single sector write or a multi-sector write. In operation 904, the memory write is written to the second block of the update metablock. For example, block 822a (eg, the second block) of update metablock 820 may correspond to block 802a of original metablock 800. Writing a memory write to the second block of the update metablock corresponding to the first block of the original metablock, such that the memory is written to update the appropriate portion of the original metablock (eg, writing memory to write Block 822a is entered to update block 802a). As further discussed with respect to FIGS. 13-8-13C and FIG. 14, according to some embodiments, the writes of 127724.doc -20-200842577 can be first written to a buffer (such as a scratch pad block). . The memory write can then be written to the second block during operation 906 during the described copy. In operation 906, the valid portion of the first block of the original metablock is copied to the second block of the updated το block. According to an embodiment, operation 906 can be triggered by a new write of one to another logical group, which can cause the update metablock 82 to be closed. This operation can include a portion of the waste collection. For example, as shown in Figure 8B, block 822a includes a memory write 824 plus a valid portion of block 8〇2a of original block 800. Operation 〇6 may include copying the lean material and incorporating it into the second block of the updated metablock to produce a second block including the updated valid material. As described below with respect to Figures i3A through 14 and 14, the operations may include copying new data written by the memory to a buffer, and writing the new data in memory in a logical order along with the original block. The valid portion of the _block is copied into the second block of the updated metablock. Iy In operation 908, the second block of the update metablock is linked to the original block. According to an embodiment, bonding the second block of the update metablock to the original block may include several operations. First, the first block is decoupled from the original metablock (e.g., block 802a) (i.e., the link is unlinked). Next, the second block of the more 'block' is de-related from the updated meta-block (eg, 'block 822a). Finally, the second block of the updated meta-block is linked to the rest of the original meta-block (eg, The block is closed to form a re-bonded original block (see, for example, Figure 8B). The original element block is the waste collection block updated with the data of the memory writer (for example, memory write 127724.doc -21- 200842577 824). For example, the re-linked original metablock 800 shown in Figure 8B includes a block 822a and a memory write 824 from the update block 820. The re-linked original block 8〇〇 also includes unmodified blocks 8〇2b to 802d. As demonstrated by equation (2), the amount of time for the waste collection update block 820 can be reduced by re-linking the meta-blocks during the waste collection. In addition, the re-linking of the metablocks can be combined with staged waste collection to avoid time-out errors. Figures 10A through i〇c illustrate the re-linking of a metablock when a host write command updates a logical group using an open update block during garbage collection. Figure 10A illustrates an original metablock 1〇〇〇 and two update metablocks 1〇2〇 and 1040. The original metablock 1 is updated by the update metablock 1〇2〇. The update block 1040 updates the update metablock 1〇2〇. The update metablock 1〇2〇 may include updated material (e.g., memory write) for one or more of the original metablocks 1000. According to an embodiment, the update metablock 104A includes updated material for updating a block of the metablock 1020. According to a embodiment, the update block 1 〇 4 〇 can be a flow entity configured for waste collection operations. Once the re-link is completed, the update block 1〇4 can be returned to the pool of updated metablocks. The update metablock 丨〇2〇 can remain open as long as it is not full and no other writes call it to close. The original metablock 1000 includes four blocks 1002 & to 1002d. The update metablock 1020 includes four blocks 1022 & to 1022d. Each of the four blocks 1022a through 1 022d of the update metablock 1 〇 2 包括 includes updated material for each of the four blocks 1002a through 1002d of the original metablock. The update block 1〇4〇 includes a memory write 1〇44 located in a block 1042c and an empty block 127724.doc -22- 200842577 1042a, 1042b, and 1042d. Memory write i〇44 will update block 1022c of update block 1020. Similar to the case described with respect to Figs. 8A, 8B, and 9, when the scrap collects the update block 1040, only the block i 〇 42c is collected by the waste. The other blocks 1042a, 1042b, and 1042d are empty, and the blocks 1〇42c are re-linked into the update block 1020, while the other blocks 1042a, 1042b, and 104d can be deprecated and reconfigured. Depending on the situation, the block i〇22c of the update block 1020 or the block l〇〇2c of the original block 1000 may be used to collect the block i〇42c. Figure 12 depicts a process for determining which block to collect waste. Both cases are described herein; Figure 10B shows an updated metablock 1020 that has been collected by waste, and Figure 10C shows a raw block that has been collected by waste. Typically, if the memory write 1044 update has been written to the logical address of the update metablock 1〇2, the update metablock 1020 is garbage collected using the update metablock 1〇4〇. Otherwise, the original metablock 1000 is garbage collected using the update metablock 1〇4〇, and then the original metablock 1000 is garbage collected using the update metablock 1020. Regardless of which block is first collected by the scrap, the original metablock 1000 is used to scrap the resulting updated metablock 1020 to merge the updated metablock 1〇2〇 with the original metablock 100 valid data. FIG. 1A illustrates a meta-block 1020 collected by waste according to an embodiment. First, the block 1 〇 42c including the memory write 1044 is collected by copying the valid portion of the block 1022c into the block 1 〇 42 。. The block l〇22c updated by the update metablock 1040 is released from the update metablock 1〇2〇. Block 1042e is then linked to metablock 1() 2().指出 The relationship between the blocks l〇22a, 1022b, 1042c and 1022d is indicated in the block key 127724.doc -23- 200842577 as described in the text (ie, it forms the element block 1〇2〇) . After the link, the block i 〇 42c effectively replaces the block i 〇 22c in the update block 1020. After the block 1042c is linked to the update metablock 1() 2, the updated metablock 1020 can be used to update the original metablock 1〇〇〇. The update of the original metablock can be performed using any type of waste collection (including staged waste collection) and can further include another example of metablock re-linking. Figure 10C illustrates an alternative scenario in which the original metablock 1000 can be used to garbage collect the second update metablock 1040, in accordance with an embodiment. In some cases, for example, if the logical address of the memory write 1044 has not yet been written to block 1022c (ie, the update metablock is updated, the updated metablock is not yet written. As part of this, the original metablock 1〇〇〇 can be used to collect the updated metablocks 1〇4〇 before the update metablock 1020 updates the original metablocks 1〇〇〇. For example, Figure i〇c shows that block 1042c has been garbage collected using block 1002c, and block 1042c has been relinked into the original metablock. The update metablock 1〇2〇 is unchanged; the updated metablock 1020 can then be collected using the re-linked original metablock 1〇(9). According to another embodiment, as described with respect to Figures 15 and 16, the update metablock 1020 may or may not use the metablock 1 to collect waste. As described above, the metablock 1020 and the original metablock can be combined and updated using any suitable waste collection technique, including staged waste collection and re-linking as described herein. 11A is a flow chart for describing a second update metablock updating a first update metablock during waste collection and a memory write in the second update metablock being written to include written One of the first updated metablocks of the data is 127724.doc -24- 200842577. The address is re-linked to the π-private 1100. This process 1100 generally depicts the situation shown in Figure 10A. In operation 1102, a receive command is received, which includes a memory writer for updating a -th block of the first metablock. As described above, the memory write can be a single sector memory write or a multi-sector verb write. The first metablock may be a first updated metablock (e.g., updated metablock i_) updated by a second updated metablock (e.g., update metablock 1040). Example η

In other words, the first block may be the updated block of the updated metablock block 1022c. In operation 1HM, the memory write writer is written to the _th block of the second metablock. The second block of thai may be a second update block that updates the first update block (eg, 'update block 1〇4〇). The second block may be, for example, a block 1 of the updated meta-ghost 40. According to an embodiment, the first block and the second area & can be configured from the same memory plane (e.g., see Fig. 2). According to an embodiment, the memory write can be written to a buffer (10), a scratch pad block) and the memory write can be written to during the garbage collection (eg, during operation 丨丨〇6) The second block. According to another embodiment, the memory write can be written to some other memory location (such as anywhere in RAM or other memory). In operation 1106, the valid portion of the first block of the first metablock is copied to the second block of the second metablock. Operation 11〇6 may include portions of waste collection as described above. In operation 1108, the second block of the second metablock is linked to the first block. As described above, operation 1108 can include re-linking. For example, 127724.doc -25- 200842577 can make the first block and the first element block. Then, the second block can be released from the second block. Finally, the second block can be associated with the first block. The links of the metablocks can be described, for example, in a block link table. After re-linking, the first metablock can be used as the update metablock 1020 as shown in Figure 10B.

Figure 11B is a flow chart depicting a method for updating a first update metablock when a second update metablock is updated during the garbage collection and the memory writes in the second update metablock are written to the unwritten The process 1150 of re-linking is performed when the first update block is one of the logical blocks. This process 115〇 generally describes the situation shown in Figure 1〇〇. In operation 1152, a write command is received, the write command including a memory write to update a first block of one of the first update metablocks. The first update block (e.g., update metablock 1020) may update an original metablock (e.g., original metablock 1000). As described above, the memory write can be a single-sector LV write or multi-sector memory write. For example, the _th block is the block 1022c of the updated update metablock 1020. In operation 1154, the memory write is written to a second update block to a second block. For example, the second update metablock can be an update metablock 1040. The second block may be, for example, a block Μη of the updated metablock. ▲ According to an embodiment, the first block and the second block can be configured from the same memory plane (see, for example, Figure 2). According to an embodiment, the memory can be transferred to a buffer (eg, a scratch pad or other memory), and the memory can be written to the second zone during the garbage collection (eg, during operation 1156). Piece. 127724.doc -26· 200842577 In operation 1 156, the original part of the third block of the original block; &> ^ ° is copied to the second block n block. Operation ug6 may include portions of waste collection as described above. The third block of the original metablock may be a "column" block 1〇〇2c. According to an embodiment, when it is determined that the memory write is written to the logical address of the first-updated metablock of the unwritten second When the third block and the first block are merged, the third block and the second block are merged when the § memory is written to update one of the first update block without the data. In operation 115 8 , the second block of the first---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- And a ' can make the third block and the original meta block disassociated. Then, the second block can be released from the second block. Finally, the second block can be associated with the original I block. For example, the bond of the domains is described in the block-blocking table. After the re-linking, the original meta-block can be used as the original meta-block shown in Figure i〇c. Again, after re-linking The first-update metablock may update the original metablock. Figure 12 is a diagram for describing when the plurality of update metablocks are open according to the embodiment: which one will be re-linked The process of the process 12 。. Example and 5 ' can use the process 1200 to decide whether to re-bond a waste collection block to the original element block or re-link to another - update element block. For example, in a case where a memory write to update a logical group already has an open update metablock (for example, the case shown in FIG. 10A): Process 1200. In addition, there may be no open update. In the case of a metablock (see, for example, operation 1204), process 12A is used. In operation 12〇2, a write command including a memory write is received. The 127724.doc -27- 200842577 is (for example) Sector write or multi-sector write (such as memory = 4). Write the memory write to the available update metablock. Or 'Write the memory to the other-logical group.," , T has an open update block in the operation blue, determines whether there is an original meta block (for example, original

Another open updated metablock of 70 blocks or ensembles (e.g., update block 1020). If there is no other open update metablock on the right, then in operation η(10), the decision will re-link the original metablock (e.g., the original metablock 8〇〇) (see, for example, Figure 8B). When the original metablock 8〇〇 is re-bonded, for example, update

Block 822a of block 820 replaces the block purchase of the original block, as shown in Figure 8B. If there is another open update metablock (as determined in operation 12〇4), then process 1200 continues to operation, where it is determined whether the logical address of the memory writer has been written to other open update metablocks. in. If the logical address written to the memory has been written to the open update metablock, then in operation 1210, the updated metablock is opened. For example, as shown in FIG. 10B, the § memory write 1 〇 44 update has a logical address already in the block 1 〇 2 〇 (; in this case, update the meta block 1 〇 2 The block 1〇2〇c will be re-linked. If the memory write is written to a logical address that does not exist in other open update metablocks, then in operation 1206, the original element is re-linked. For example, as shown in FIG. 10C, the memory write 44 writes to a logical address that is not occupied by the data of the block 1022c of the update metablock 1020. In this case, the garbage collection Block 1042c and it is newly bonded to the original metablock 1 127 127724.doc -28- 200842577. Re-linking while preserving the offset of the block Figures 13A-13C illustrate the use of the region according to an embodiment Compensation for offset changes in the block. When reading a unary block, individual blocks of the metablock can be read in parallel. For example, the unary block 1300 includes four individual blocks 1302a through 1302d. Each of 〇2&, 1302b, 1302c, and 1302d includes a number of pages 1304, 1306, 1308, and 1310, respectively. At block 1300, block 13〇2 can be read in parallel; for example, r, 'pages 1304a, 1306a, 1308a, and 1310a can be read simultaneously. Next, pages 1304b, 1306b, 1308b, and 1310b will be read. When a block is collected, the process of garbage collection can change the order of pages within the block. For example, during a garbage collection operation, an update block 1320 can include a block 1322a for updating block 1302a. The update metablock can include a memory write 1324 (e.g., 'single sector or multi-sector write) for updating page 1304b. The update metablock includes a first page 1326a written to block #1322a. Memory is written 1324. Figure 13B illustrates the offset change after re-linking, according to an embodiment. After the garbage collection is completed and the block 1322a is re-linked to the meta-block 1300 - the write within block 1322a The address of the page 1304 changes. For example, the first page 1304a includes data that has been written to the second page i3〇4b. When the metablock 1300 is taken, the memory system uses a page label to compensate for this. Difference (called "offset"). This page The indication offset is signed. In this example, the page label is now different for different blocks i322a, 1302b, 1302c, and 1304d of metablock 1300. 127724.doc -29- 200842577 can be written by memory The buffer 324 buffers to a temporary location (such as a buffer (eg, somewhere in RAM) or a scratch pad block) and maintains a consistent page label throughout the metablock. Figure 13c illustrates the writing of a c-memory write to a buffer prior to waste collection. The scratch pad block 134 can temporarily store temporary storage blocks of any memory data. The memory write 1324 can be written to the scratch pad block 134, and the update block ι32 系 is empty before the garbage collection. According to various embodiments, the scratch pad block 1340 can be used as a temporary storage by a non-volatile memory system. In particular, in accordance with an embodiment of the present invention, new data (e.g., memory writes) may be temporarily stored in the scratch pad block 134 before being transferred to the update block during the merge. It should be appreciated that the temporary buffer block 134 is a form of data update block in which logical sectors within an associated logical group can be updated in machine-to-human order and in any amount of repetition. The scratch pad block 1340 is generated by a write command, and the logical sector of the celebrity does not end at the boundary of the physical page or across the boundary of the physical page 1. The idle buffer block 1340 may contain a portion of the physical page of the data, but does not allow partial stylized page material. The scratch pad block 1340 can maintain a valid data page for each updated metablock in the non-volatile memory storage system. The non-volatile memory storage system can have, for example, eight configured update metablocks, and thus the scratch pad block plus temporary storage can store nine material valid pages. During the waste collection, the active portion of block 1302a can be combined with memory write 1324 into block 1322a. Since the memory write 1324 is written from the temporary buffer block 1340, it is possible to keep the appropriate offset and page label during the waste collection period 127724.doc •30 - 200842577. According to an embodiment, a writer of one to one logical group may trigger garbage collection of another logical group. - The updated metablock for this write is not available at the time of the write. According to another embodiment, the 虡 write can be written to the update block (where the page tag can be changed), or the writer can be buffered (eg, buffered into the scratch pad block 1340) and at a later time, ', mouth / write any page label. The collection of waste from other logical groups can be performed in another way (such as two stages of waste collection), or

It can be performed using a re-link. For example, if the memory write 1324 has a logical address ' in the page u 〇 4b' then the page 13_ is first written to the block 1322 & The other valid pages of the memory write 1324 and page 13 are then written to block 13 and any other subsequent pages of page 13G4eA are written to block 1322a.完成 Completing the write in sequential logical address order can then re-link block 1322a to the original metablock using the techniques described above. Additionally, such techniques can eliminate a separate page offset for each physical block ( For example, as needed in Figure 13B). Figure 14 is a flow diagram depicting a process for re-linking (including copying memory: writes to a buffer) in accordance with an embodiment. Process 14 〇〇 generally describes the collection of scraps including re-linking blocks (including copying memory writes to buffers and = logical address order for copying - the active portion of the original metablocks and the memory intrusion). In operation 1402, a write command is received that includes a memory write with the =new-first metablock. As described above, the memory-in can be written for single-sector or multi-sector memory including update data. 127724.doc 200842577 According to an embodiment, the first metablock may be an original metablock or an updated metablock. In operation 14G4, the suffix is written to the buffer. The buffer L is stored as an A-speed temporary storage block (e.g., 'Quote Temporary Block 134') or other temporary material. As previously described, if an update metablock is available, it can also be written directly to the update metablock, and the page label of the memory write can be changed at that time. In operation 1406, a second metablock is configured. The second metablock can be, for example, an update metablock. In operation 1408, the active portion and the body write of the first block of one of the first metablocks are copied to the second block of one of the second metablocks. The active portions and the memory writes can be copied in a logical order corresponding to the first block. For example, a page of the first block may have an offset or page label and the copy retains the offset or page label. The resulting second block has the same offset as the first block. In operation 1410, the second block of the first metablock is linked to the first block. As described above, the link may include decoupling the second block from the second block C; disassociating the first block from the first metablock, and correlating the second block with the first metablock Union. Staged waste collection using re-linking while receiving a write sequence Figures 15 through 18 illustrate a process for performing a staged _ scrap collection using block re-linking. More specifically, these figures describe various situations during which a sequence of write commands (e.g., multiple single-sector or multi-sector writes) is received. Figures 15 through 16 and Figures 17 through 18 each depict the use of block re-linking (as depicted in Figures 7 and 8) in association with staged waste collection. 127724.doc -32- 200842577 Figure 15 is a flow diagram depicting a process 1500 for performing a first instance of staged waste collection (including re-linking) while receiving a memory write sequence, in accordance with an embodiment. Figure. Figure 16 illustrates a first scenario of staged waste collection (including block re-linking) in accordance with an embodiment. The process 丨5〇〇 usually describes two memory writes. The first memory write is written to the first block, and then the second memory write is written to the second block. The second memory write can trigger a garbage collection of updated metablocks written with the first memory write. Figure 16 illustrates two logical groups (e.g., metablocks) 16" and 161". Each of the logical groups 1600 and 1610 is a metablock comprising two blocks 1602 and 1612, respectively. In operation 15〇2, a write is received to the address χ in the block 16〇2& of the metablock 1600. This address X can be any address within the block. When the write is received, the first update metablock 1 is open in operation 1504. The update block 162 can be used to update the metablock 1600. The first update metablock can be written in two stages. For example, a write to address X can be a single sector write that is assigned a timeout period. In operation 1506, the first stage of garbage collection may be performed during a timeout period. The first stage of waste collection may include copying the valid data (i.e., the data from block 1602a that is not from the address to which the write was written plus the write) to the first update block. Block 1622a. In operation 1508, a second write command is received. The second write command can be written to block 1612a of metablock 161. The second write command opens a first update 7L block 1630. In some cases, there may be no additional updated metablocks available 127724.doc -33 - 200842577, so the first update metablock 1620 should be closed before the second update metablock 1630 can be configured (ie, the first update should be completed) ). However, there may not be sufficient time before the expiration of the timeout period used to complete the write of the first update metablock 1620. A re-link can be used to close the first update metablock 1620 before the timeout period expires. In operation 1510, the remainder of the garbage collection for block 1622a of the first update metablock 162 is completed. Scrap collection may include copying valid data from the memory write (e.g., written sectors) and block l6〇2a into block 1622a. In block 1512, block 1622a (i.e., the first update block) is linked to block 1602b (i.e., the original block) to produce a new block. The new metablock includes updated metablocks written by the memory. Since the new metablock has been updated, process 1500 can close first update metablock 162 and open second update metablock 1630. The re-linking between blocks 1602b and 1622a is shown by line 1632. Additionally, as discussed above with respect to Figures 13-14, the page label can be maintained during process 15〇〇. Figure 17 is a flow diagram depicting a process 17 for performing a second phase of phased waste collection (including re-linking) while receiving a memory write sequence, in accordance with an embodiment. This process 17 〇〇 describes a series of four writes. Some of the writes in these writes can trigger waste collection. Figure 18 illustrates a number of metablocks of a process 1700 that can be used to describe the second case. In operation 1702, a write of address a in block 1802a of metablock 1800 is received. The address a and any other address described herein are arbitrary, # and may represent any address within the block in which it resides. The block 1800 can include 127724.doc -34- 200842577 with two blocks 1802a and 182b. The write may also generate a first update block 1820, which includes two blocks 182 and 1822b that are open. In operation I', a write of the address b in the block (8) of the metablock l8i is received. The metablock 181A may contain two blocks 181 and 1812b. According to an embodiment, the in-place write may trigger a garbage collection of the update metablock 1820 (corresponding to the write to address a). After operating the m6 towel, buffer the address bn to the high-speed temporary storage area.

L block (or buffered to any other location within the memory storage system). The sector that has been written may be buffered to allow writing to the δH sector at a later time after other merging has been completed. ^ After the sector has been buffered, in operation 17 〇 8, the first update element block 1820 is started. Waste collection. According to an embodiment, a portion (e.g., half) of the waste collection of the updated metablock may be completed during the first one busy period. In operation 171, a one to address is received. Write. Since the write is received to the address G, the remainder of the garbage collection for the update metablock 1820 is completed in operation 1712. In operation 1714, the sector of the scratch pad block will be buffered in operation 1706 (also That is, the writer to b) writes to the second update = block 1830, and in sector 1716 writes the sector written to address e to the south speed temporary block (or other storage at operation 1718) In the reception, the write to the address d. The write in place (4): triggers the collection of waste for the second update block 183G. This waste collection can be a staged waste collection including re-linking. In other words, the waste collection can be completed during one or more busy cycles. Between the waste retractions, only the data is written to block 1832a of block 1830. J 耆 耆 127 724724.doc -35 - 200842577 Block 1832a is re-linked to block 1812b of block 18 10. The re-link between blocks 1802b and 1822a is shown by wire 1834. Additionally, as described above with respect to Figures 13-14, The 17th Gate maintains the page label. "im officials have slightly detailed for the purpose of understanding Administered at the intersection of said upper

C i examples, but the embodiments are not limited to the details provided. There are many alternative ways of implementing embodiments and the like. Therefore, the disclosed embodiments are to be considered as illustrative and not restrictive, and the embodiments are not limited to the details modify. In the scope of the patent, unless specifically stated in the scope of the patent, the elements and/or operations do not imply any specific operation. [Simplified description of the drawings] Figure 1 is a non-volatile according to the embodiment of the present invention. A simplified block diagram of an example of a memory storage system; "Figure 2 is a simplified block diagram of the organization of the memory cell array in a plane. Figure 3 is a simplified block diagram of a page of memory cells; Figure 4 is a memory cell Simplified block diagram of the sector; a logical block diagram between the storage systems is a simplified block diagram of the interface between the host and the non-volatile memory; Figure 6 is based on the present day _, 〇 ^ month - the embodiment A flow chart for a general overview of a staged waste collection; Figure 7 shows a simplified block diagram of a waste collection operation in accordance with the present invention - > 4 knives 127724.doc • 36- 200842577 Figures 8A-8B illustrate block re-linking when updating a primitive block to update a primitive block, according to an embodiment; Figure 9 is a diagram for describing waste collection in accordance with an embodiment. Re-key during Flowchart of the process of unary block; 'Fig. 10A to Fig. 10C illustrate the re-linking of the metablock when one update block is updated by another update block during the garbage collection; FIG. 11A is a first-class private diagram, which describes one use Performing a second update metablock to update a first update metablock during the garbage collection and the second update metablock memory write is written to a logical address of the first update metablock including the written data. FIG. 11B is a flowchart for describing a second update metablock to update a first update metablock during waste collection and a memory write in the second update metablock to be written. The process of re-linking into the logical address of the first updated metablock that has not been written; FIG. 12 is a diagram for deciding which link will be re-linked when multiple update metablocks are open, according to an embodiment. Flowchart of a process of a unitary block; Figures 13A-13C illustrate compensation for offset changes in a block, according to an embodiment; Figure 4 is a diagram for re-linking (including one) according to an embodiment Remember to write a copy to a buffer) Figure 1 is a flow diagram depicting a first scenario for performing staged waste collection (including re-linking) while receiving a sequence of memory writes, in accordance with an embodiment; 16 illustrates two logical groups (eg, metablocks); 127724.doc -37- 200842577 FIG. 1 is a diagram for performing staged waste collection while receiving a sequence of memory writes in accordance with an embodiment. A flow chart of the second case (including re-linking); and Figure 18 illustrates a number of meta-blocks that can be used to describe the process of the second case. [Key element symbol description]

102 Non-volatile memory storage system 104 Host interface 106 Processor 108 I have a memory interface 110 Memory controller 112 Random access memory (RAM) 114 Error correction code (ECC) circuit 116 Read-only memory (ROM) 118 Memory 120 Array Logic 122 Non-volatile Memory Cell Array, j 124 Bus 126 System Bus 202 Plane 203 Plane 204 Plane 205 Plane 210 Block 211 Block doc -38 - 200842577 212 Block 213 Block 220 Block 221 Block 222 Block 223 Block 224 Block 401 Page 402 Sector 404 Sector 405 Additional Item 406 Data 502 Memory Cell Array 512 Block 512 Logical Address Space 702 Busy Signal 704 Multi-Sector Write Incoming command 706 Stop command 750 Timeout period 751 Timeout period 752 Timeout period 760 Poor sector 761 Poor sector 762 Data sector 127724.doc -39- 200842577 780 Stage 781 Stage 800 Original element block 802a Block 802b Block 802c block 802d block 820 update metablock 822a block 822b block 822c block 822d block 824 Memory Write 1000 Original Block 1002a Block 1002b Block 1002c Block 1002d Block 1020 Update Element Block 1022a Block 1022b Block 1022c Block 1022d Block 1040 Update Element Block 127724.doc -40- 200842577 1042a Block 1042b Block 1042c Block 1042d Block 1044 Memory Write 1300 Element Block 1302a Block 1302b Block 1 1302c Block 1302d Block 1304a Page 1304b Page 1304c Page 1304d Page 1306a Page 1306b Page 1306c Page 1306d Page. 1308a Page 1308b Page 1308c Page 1308d Page 1310a Page 1310b Page 127724.doc •41 · 200842577 1310c Page 1310d Page 1320 Update metablock 1322a Block 1322b Block 1322c Block 1322d Block 1324 Memory Write 1340 Office Speed Block 1600 Logic Group/meta block 1602a block 1602b block 1610 logical group/meta block 1612a block 1612b block 1620 first update metablock 1622a block 1622b block 1630 second update metablock 1632 connection 1800 metablock 1802a zone Block 1802b block 1810 block 127724.doc -42- 200842577 1812a Block 1812b Block 1820 First 1822a Block 1822b Block 1830 Second 1832a Block 1832b Block 1834 Connection P0-P7 Page Update Element Update Element 127724.doc -43

Claims (1)

  1. 200842577 X. Patent application scope: 1. A non-volatile memory storage system comprising: - a memory configured to store a storage system; - a non-volatile memory unit array configured To maintain a first domain, the first metablock includes a block of the first metablock; and - a processor that communicates with the memory and the non-volatile memory single (four) column 'the processor is configured To execute the storage system stored in the memory, the storage system dynamic body includes a program instruction for: τ &, m memory writer to update the block-block to - a block of the first metablock; copying the valid portion of the block of the first metablock to the block of the second metablock; and the block links the block of the second block to The first element block. 2 · For example, the non-volatile printing of the item 1 _ μ 士 ^ "Situ storage system, in which the block of the second 1 / 70 ghost is linked to the first - meta block contains · 2:&quot - the block of the metablock is de-related from the first metablock; - the block of the unresolved relationship '· and the 70 block is released to generate - a block associated with the unresolved relationship is associated with the first metablock The non-volatile memory storage system of the phantom item 1, wherein the retracement component comprises performing a staged waste collection. Effective 4·:: Item 1 of the non-volatile memory storage system, wherein the link is" One of the blocks contains an update-block link table. The non-volatile memory storage system of claim 1, wherein the writing of the memory write to the block of the second metablock comprises writing the memory write to a first An update block is one of the blocks. 6. The non-volatile memory storage system of claim 5, further comprising receiving the write command, the write command including a memory write to update a second update block. 7. The non-volatile memory storage system of claim 1, the program instructions further comprising configuring the block of the first metablock and the block of the second metablock from a same memory plane. 8. The non-volatile memory storage system of claim 1, wherein writing the memory write to the block of the second metablock comprises writing the memory write to a buffer, and The copying of the memory from the first significant block of the first metablock is performed in a logical address order to copy the memory write and the valid portion to the block of the second metablock. 9. The non-volatile memory storage system of claim 8, wherein the writing of the memory write to the buffer comprises writing the memory write to a time-speed temporary storage block and a random One of the access memory (RAM). The non-volatile memory storage system of claim 1, further comprising a receive edge write command, the write command comprising a single sector memory write 0 11 · a non-volatile memory storage system And comprising: = a memory configured to store a storage system firmware; a non-volatile memory unit array configured to maintain a first updated metablock 'the first-updated metablock containing the first An update block 127724.doc 200842577 block, and a processor in communication with the memory and the non-volatile memory cell array, the processor is configured to execute the storage system stored in the memory The firmware, the storage system firmware includes a program instruction for: the following command: the write command includes - a memory write to update the block of the first update block, The first update metablock uses f to update an original metablock; writes the memory write to one of the second update metablocks; and copies the valid portion of the original metablock to the first Second update the block of the metablock And updating the second block of the block element to link the original metablock. 12. If the non-volatile memory storage system of the request is requested, the program instructions further include updating the original metablock using the first update metablock after the link. u 13. The non-volatile memory storage system of claim 11, the program instruction progress comprising configuring the block of the first update metablock and the region of the second update metablock from a same memory plane Piece. '14. The non-volatile memory storage system of claim 11, the program instructions - the step comprising: determining that the memory writer is written to the first one of the first update metablock Update one of the logical blocks of the metablock. 15. The non-volatile memory storage system of claim 11, wherein linking the block of the second update metablock to the original metablock comprises: causing the block of the second update metablock and the first The second update block release 127724.doc 200842577 is to generate a block that has been released from the relationship; the block of the original metablock is released from the original metablock; and the unblocked block and the original element are Blocks are associated. 16. The non-volatile memory storage system of claim 11, wherein writing the memory write to the block of the second update metablock comprises writing the memory write to a buffer, and The memory is written in an order and the valid portions of the block of the original block are copied to the block of the second updated metablock in an order during a garbage collection operation. η. The non-volatile memory storage system of claim 16, wherein writing the memory write to the buffer comprises writing the memory write to a high speed temporary block. 18. A non-volatile memory storage system as claimed in claim 1, wherein the copy retains a page label of the block of the first update metablock. 19. A non-volatile memory storage system comprising: - a memory 'configured to store a storage system firmware; - a non-volatile memory single (four) column, (4) to maintain a first element Block, the first metablock including the block of the first metablock; and a processor in communication with the far delta memory and the non-volatile memory cell array, the processor configured to perform the storing on the The storage subsystem in the memory, and the firmware of the storage system contain program instructions for the following operations: Receive a tank to write command, the ancient female Xuan ' λ everyone l Μ write command contains a update Memory writing of the first metablock; writing the memory write to the buffer; 127724.doc 200842577 configuring a second metablock; the logical order corresponding to the first metablock The valid portion of the block of the unary block and the memory are written and copied to one of the blocks of the second block; and the block of the second block is linked to the first block. 20. The non-volatile memory storage system of claim 19, wherein writing the memory write to the buffer triggers garbage collection in another logical group.
    2 1 . The non-volatile memory storage system of claim 19, wherein the copy valid portion is executable during subsequent host writes. 22. The non-volatile memory storage system of claim 19, wherein receiving the write command comprising the memory write to update the first metablock comprises receiving the inclusion of one for updating a & ^ 写入 The write command of the original 70 block memory write. 23. The non-volatile memory storage system of claim 19, wherein configuring the first unary block comprises configuring a first update metablock. 24. Non-volatile memory storage according to item 2 3 includes the memory for updating the first element block. The receiving one includes a second update write command for updating. The system, in which the packet is written, the write command contains the memory written by the block. 25 such as the request item! A non-volatile memory retention system, wherein writing the memory write to the buffer comprises writing the memory write to the temporary buffer block. 26. The non-volatile print of claim 19 is a "scorpion storage system in which the active portion is copied by the logic 127724.doc 200842577 _ human order and the memory writer is included in the copy One of the offsets of the second metablock is retained during the period. 27. The non-volatile memory storage system of claim 19, wherein linking the block of the second metablock to the first metablock comprises: causing the block of the first metablock and the first The metablock disengages the relationship; the block of the second metablock is decoupled from the second metablock to generate a deblocked relationship; and the deblocked relationship is associated with the first metablock. 28. The non-volatile memory storage system of claim 20, wherein the program instructions further comprise selecting to use the staged waste collection or using the re-dragon to perform the waste collection for the other group. 29. A method comprising: updating a block of a metablock to write a memory write to block a block of a second metablock; == and the block of the metablock is valid Partially copying to the second metablock links the block of the second metablock to the first metablock. The method of claim 29, wherein linking the block of the second metablock to the first metablock comprises: disassociating the block of the first metablock from the first metablock And causing the block of the second metablock to be decoupled from the second metablock to generate a deblocked relationship; and associating the unblocked block with the first metablock. 31. The method of claim 29, wherein copying the valid portions comprises performing a staged waste collection of 127724.doc 200842577. The method of claim 29, wherein the block that binds the second metablock comprises updating a block link table. 33. The method of claim 29, wherein writing the memory write to the block of the second metablock comprises writing the memory write to the block of a first update block. 34. The method of claim 33, further comprising receiving a write command, the write command including a memory write to update a second update metablock, eg, request method 29, further The block including the first metablock and the block of the second metablock are configured from a same memory plane. The method of claim 29, wherein writing the memory write to the block of the second block comprises writing the memory write to a buffer, and the copy is from the The effective portion of the block of the unary block
    The memory write and the valid portions are copied to the block of the second metablock in logical address order. 37. The method of claim 36, wherein writing the memory write to the buffer comprises writing the memory to a write-to-scratch block and a random access memory (RAM) One of them. %. The method of claim 29, further comprising receiving a write command comprising a single sector memory write. 39. A method, comprising: receiving a write command, the write command comprising a block of a block of updated metablocks for updating a first memory write, the first update block being used for 127724. Doc 200842577 updates an original metablock; writes the memory write to a block of a second update metablock;; the original metablock - the valid portion of the block is copied to the region of the second update metablock Blocking; and linking the block of the second update metablock to the original metablock. 40. The method of claim 39, further comprising updating the original metablock using the first updated metablock after the bonding. 41. The method of claim 39, further comprising configuring the block of the first updated metablock and the block of the second updated metablock from the same memory plane. 42. The method of claim 39, further comprising determining that the memory write is written to a logical address of the first-update metablock that is not written to the first-update metablock. The method of claim 39, wherein the associating the second update element block to the original element block comprises: the brother key causes the block of the second update element block to be .l7., L-tail, the first update The metablock disengages the relationship to generate a block that has been released from the relationship; deactivates the block of the original metablock from the original metablock; and associates the unblocked block with the original metablock. The method of claim 39, wherein writing the memory write to the block of the second update block comprises writing the memory write to a buffer, and collecting the money in the waste The valid portion of the block in which the memory is written to = original block is copied to the block of the new metablock. The method of claim 44, wherein the writing of the memory is written to the user and the memory is written to the temporary buffer block. The method of -= = 39, wherein the copy retains one of the page labels of the block of the first metablock. 47. A method comprising: a receive-write command, the write command comprising a memory write for updating - a block; C writing the write to a buffer; Configuring a second metablock; ^__ should be in the logical order of the first metablock, the valid part of the first block and one of the ghosts; and the body of the person «to the second metablock" The block of the first block is linked to the first block. 48. If the request item 47 is a little bit crying, the memory is written to the m-touch-other logical group. 4 rushing As for the method of Jing Chang 47, the towel can be copied to the effective part. During the U-master write, 50. If the request item 47 element block is received, the receiving command for updating the first-new-origin:: includes receiving the inclusion-for a further 51. · As requested, the party to and from the 47th. An updated metablock. The first first block contains a configuration 52. The grammar of the metablock of claim 51 receives the write command containing a write to update the first corpusle including receiving an inclusion-for 127724. Doc 200842577 New one second #虹-1 ~ update 7L block memory write writes. 53. The method of claim 47, wherein the memory buffer comprises writing a granular write to the buffer, and "5 recalling writes to a cache block. 54. ^Request The method of item 47, wherein the knives are copied in the logical order: the C memory writes include retaining the first: </ RTI> offset during the copying. The present invention is the method of claim 47, wherein the - the metablock contains: &lt;blocks of the block link to:: Hai: - the block of the metablock and the first metablock release relationship; a brother-seven block release relationship to generate the relationship Blocking; and associating the block of the disengaged relationship with the first metablock. 56. If the method of claim 48 is used, J: _ _ 勹 隹 、, / V 匕 3 choose to use the staged waste Collection or use of re-linking to carry out. Vanadium 仃 receives the waste from another group 127724.doc
TW96150023A 2006-12-28 2007-12-25 System for block relinking TW200842577A (en)

Priority Applications (2)

Application Number Priority Date Filing Date Title
US11/648,487 US20080162612A1 (en) 2006-12-28 2006-12-28 Method for block relinking
US11/647,906 US20080162787A1 (en) 2006-12-28 2006-12-28 System for block relinking

Publications (1)

Publication Number Publication Date
TW200842577A true TW200842577A (en) 2008-11-01

Family

ID=39319707

Family Applications (1)

Application Number Title Priority Date Filing Date
TW96150023A TW200842577A (en) 2006-12-28 2007-12-25 System for block relinking

Country Status (2)

Country Link
TW (1) TW200842577A (en)
WO (1) WO2008082950A1 (en)

Cited By (1)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
TWI409631B (en) * 2009-04-15 2013-09-21 Silicon Motion Inc Flash memory device and method for operating a flash memory device

Families Citing this family (3)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US8566504B2 (en) 2007-09-28 2013-10-22 Sandisk Technologies Inc. Dynamic metablocks
US9465732B2 (en) 2013-03-15 2016-10-11 Sandisk Technologies Llc Binning of blocks for dynamic linking
US9626289B2 (en) 2014-08-28 2017-04-18 Sandisk Technologies Llc Metalblock relinking to physical blocks of semiconductor memory in adaptive wear leveling based on health

Family Cites Families (3)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US7139864B2 (en) * 2003-12-30 2006-11-21 Sandisk Corporation Non-volatile memory and method with block management system
US20050144516A1 (en) * 2003-12-30 2005-06-30 Gonzalez Carlos J. Adaptive deterministic grouping of blocks into multi-block units
US7631138B2 (en) * 2003-12-30 2009-12-08 Sandisk Corporation Adaptive mode switching of flash memory address mapping based on host usage characteristics

Cited By (1)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
TWI409631B (en) * 2009-04-15 2013-09-21 Silicon Motion Inc Flash memory device and method for operating a flash memory device

Also Published As

Publication number Publication date
WO2008082950A1 (en) 2008-07-10

Similar Documents

Publication Publication Date Title
US8041884B2 (en) Controller for non-volatile memories and methods of operating the memory controller
TWI400608B (en) A method of transferring data between a host system and a re-programmable non-volatile semiconductor mass storage system, a method for operating a controller in a flash memory system, and a mass storage memory system
DE60217883T2 (en) Method for writing data into a non-volatile memory
EP2286341B1 (en) Method and system for storage address re-mapping for a multi-bank memory device
JP4155824B2 (en) Partial block data programming and reading operations in non-volatile memory
KR100914263B1 (en) Scratch pad block
JP5026213B2 (en) Storage apparatus and data deduplication method
EP1920317B1 (en) Mass data storage system
KR100526188B1 (en) Method for address mapping and managing mapping information, and flash memory thereof
TWI421684B (en) Reprogrammable non-volatile memory system and method of operating a non-volatile memory system
Hu et al. Write amplification analysis in flash-based solid state drives
KR101369996B1 (en) Method and system for dual mode access for storage devices
US8621323B2 (en) Pipelined data relocation and improved chip architectures
KR100468880B1 (en) Nonvolatile memory device, nonvolatile device control method and information recording medium on which program for controlling nonvolatile recording device is recorded
US7877540B2 (en) Logically-addressed file storage methods
EP1576478B1 (en) Method and apparatus for grouping pages within a block
CN101739352B (en) Method for managing storage device and related storage device thereof
US20120191927A1 (en) Wear Leveling for Non-Volatile Memories: Maintenance of Experience Count and Passive Techniques
US20040186946A1 (en) Flash file system
JP4931810B2 (en) FAT analysis for optimized sequential cluster management
US20040264254A1 (en) Erase block data splitting
KR20120106801A (en) Data transfer flows for on-chip folding
US9176817B2 (en) Data management in solid state storage devices
TWI432960B (en) Method of operating memory unit, memory controller and memory system
EP1828881B1 (en) Cluster auto-alignment