Storage device and method of operating the same

Abstract

A memory device and a method of operating the same are provided. An example method of operating a storage controller storing one or more logical-to-physical (L2P) tables includes receiving a request from a host to modify a first logical page number (LPN), inserting a first node corresponding to the first LPN between a second node associated with a second LPN and a third node corresponding to a third LPN, and determining whether the first L2P table is the same as the second L2P table based on the number of pages in the L2P table of the one or more L2P tables. The first L2P table includes a first LPN. The second L2P table includes a second LPN.

Description

[0001] This application claims priority to Korean Patent Application No. 10-2023-0193179, filed with the Korean Intellectual Property Office on December 27, 2023, the disclosure of which is incorporated herein by reference in its entirety. Technical Field

[0002] This application relates to a storage device and a method of operating the same. Background Art

[0003] A logical page number (LPN) and a physical page number (PPN) may be managed by a mapping table called a logical-to-physical (L2P) table. The L2P table and metadata related to the L2P table may be stored in a static random access memory (SRAM). A method for reducing the overhead of the L2P table and metadata related to the L2P table is desired. Summary of the Invention

[0004] This disclosure relates to a storage device and a method of operating the same, the method including a method for managing metadata for a storage device.

[0005] Generally, according to some aspects, a method of operating a storage controller storing one or more logical-to-physical (L2P) tables includes: receiving, from a host, a request for modifying a first logical page number (LPN); inserting a first node between a second node and a third node, the first node corresponding to a first LPN, the second node being related to a second LPN, and the third node corresponding to a third LPN; determining whether a first L2P table including the first LPN is the same as a second L2P table including the second LPN based on the number of pages in an L2P table among the one or more L2P tables; determining whether the first L2P table including the first LPN is the same as a third L2P table including the third LPN based on the number of pages in an L2P table among the one or more L2P tables; and increasing a dirty L2P table counter based on a comparison by 1 when the first L2P table is different from both the second L2P table and the third L2P table. Among LPNs less than the first LPN, the second LPN is the largest in a group of LPNs closest to the first LPN. The group of LPNs includes at least one consecutive LPN. Among LPNs greater than the first LPN, the third LPN is the smallest. The first node, the second node, and the third node have a doubly linked list structure.

[0006] Generally, according to some aspects, a method of operating a storage controller that stores one or more logical-to-physical (L2P) tables includes: receiving, from a host, a request to modify a first logical page number (LPN); inserting a first node between a second node and a third node, the first node corresponding to the first LPN, the second node associated with a second LPN, and the third node associated with a third LPN; determining whether a first L2P table including the first LPN is the same as a second L2P table including the second LPN based on the number of pages in an L2P table among the one or more L2P tables; determining whether a first L2P table including the first LPN is the same as a third L2P table including the third LPN based on the number of pages in an L2P table among the one or more L2P tables; and incrementing a comparison-based dirty L2P table counter by 1 when the first L2P table is different from both the second L2P table and the third L2P table. Among the LPNs less than the first LPN, the second LPN is the largest in the LPN group closest to the first LPN. The LPN group includes at least one consecutive LPN. Among the LPNs greater than the first LPN, the third LPN is the smallest. The first node, the second node, and the third node have a singly linked list structure and a tree structure.

[0007] Generally, according to some aspects, a storage controller includes: a static random access memory (SRAM) configured to store one or more logical-to-physical (L2P) tables, a comparison-based dirty L2P table counter, and a plurality of nodes corresponding to a plurality of LPNs; and a processor. The processor is configured to: receive, from a host, a request to modify a first logical page number (LPN); insert a first node corresponding to the first LPN between a second node associated with a second LPN and a third node corresponding to a third LPN; determine whether a first L2P table including the first LPN is the same as a second L2P table including the second LPN based on the number of pages in an L2P table among the one or more L2P tables; determine whether a first L2P table including the first LPN is the same as a third L2P table including the third LPN based on the number of pages in an L2P table among the one or more L2P tables; and increment a comparison-based dirty L2P table counter by 1 when the first L2P table is different from both the second L2P table and the third L2P table. Among the LPNs less than the first LPN, the second LPN is the largest in the LPN group closest to the first LPN. The LPN group includes at least one consecutive LPN. Among the LPNs greater than the first LPN, the third LPN is the smallest. The first node, the second node, and the third node have a doubly linked list structure. BRIEF DESCRIPTION OF THE DRAWINGS

[0008] Embodiments will be understood more clearly from the following detailed description in conjunction with the accompanying drawings.

[0009] Figure 1 A block diagram showing an example of a host-storage device system.

[0010] Figure 2 An example of a storage controller is shown.

[0011] Figure 3 A diagram showing an example of an L2P table.

[0012] Figure 4 A diagram showing an example of a dirty L2P table count (or dirty L2P table counter).

[0013] Figure 5 An example of a method for managing a comparison-based dirty L2P table counter is shown.

[0014] Figure 6 An example of a method for managing a comparison-based dirty L2P table counter is shown.

[0015] Figure 7 An example of a method for managing a comparison-based dirty L2P table counter is shown.

[0016] Figure 8 An example of a method for managing a comparison-based dirty L2P table counter is shown.

[0017] Figure 9 An example of a method for managing a comparison-based dirty L2P table counter is shown.

[0018] Figure 10 An example of a method for operating a storage controller is shown.

[0019] Figure 11 An example of L2P table identity determination is shown.

[0020] Figure 12 An example of a method for operating a storage controller is shown.

[0021] Figure 13 An example of an operation process of a computing device is shown.

[0022] Figure 14 An example of a block diagram of a Universal Flash Storage (UFS) system is shown. Detailed Description

[0023] Various embodiments are described below with reference to the accompanying drawings.

[0024] Figure 1 A block diagram showing an example of a host-storage device system.

[0025] Refer to Figure 1, the host-storage device system 10 includes a host 100 and a storage device 200. Additionally, the storage device 200 may include a storage controller 210 and a non-volatile memory (NVM) 220. The storage controller 210 may include an SRAM 230. The storage controller 210 may also include components (such as a processor) for controlling the storage device 200. The SRAM 230 may store a metadata context 240. The metadata context 240 may be referred to as metadata and may include logical-to-physical (L2P) table information and a comparison-based dirty L2P table counter.

[0026] The storage controller 210 may convert a logical address of a storage space managed by the host 100 into a physical address of the storage space of the non-volatile memory 220. The storage controller 210 may convert the logical address of a request received from the host 100 based on the logical address into a physical address and may respond to the request.

[0027] In some embodiments, the host 100 may include a host controller 110 and a host memory 120. The host memory 120 may be used as a buffer memory for temporarily storing data to be sent to the storage device 200 or data received from the storage device 200.

[0028] The storage device 200 may include a storage medium for storing data according to a request from the host 100. As an example, the storage device 200 may include at least one of a solid-state drive (SSD), an embedded memory, and a removable external memory. When the storage device 200 is an SSD, the storage device 200 may include a device compliant with the Non-Volatile Memory Express (NVMe) standard. When the storage device 200 is an embedded memory or a removable external memory, the storage device 200 may include a device compliant with the Universal Flash Storage (UFS) or Embedded Multimedia Card (eMMC) standard. Both the host 100 and the storage device 200 may generate packets compliant with the adopted standard protocol and send packets compliant with the adopted standard protocol between the host 100 and the storage device 200.

[0029] When the non-volatile memory 220 of the storage device 200 includes flash memory, the flash memory may include a two-dimensional (2D) NAND memory array or a three-dimensional (3D) (or vertical) NAND (VNAND) memory array. As another example, the storage device 200 may also include various other types of non-volatile memory. For example, the storage device 200 may include magnetic random access memory (RAM) (MRAM), spin-transfer torque MRAM, conductive-bridge RAM (CBRAM), ferroelectric RAM (FeRAM), phase RAM (PRAM), resistive RAM, and various other types of memory.

[0030] In some embodiments, host controller 110 and host memory 120 may be implemented as separate semiconductor chips. Optionally, in some embodiments, host controller 110 and host memory 120 may be integrated into the same semiconductor chip. As an example, host controller 110 may include one of a plurality of modules provided in an application processor, and the application processor may be implemented as a system-on-chip (SoC). Further, host memory 120 may include an embedded memory provided within the application processor, or may include a non-volatile memory or memory module provided external to the application processor.

[0031] Host controller 110 may manage operations of storing data (e.g., recording data) of a buffer area of host memory 120 in non-volatile memory 220, or storing data (e.g., read data) of non-volatile memory 220 in the buffer area of host memory 120.

[0032] The storage controller 210 may include an SRAM 230 and a processor 213. The SRAM 230 may store L2P table information, a comparison-based dirty L2P table counter, and a plurality of nodes respectively corresponding to a plurality of logical page numbers (LPNs). The processor 213 may receive a request (a first LPN modification request) from the host 100 for modifying a first LPN. In response to the first LPN modification request, the processor 213 may insert a first node corresponding to the first LPN between a second node associated with a second LPN and a third node corresponding to a third LPN. Before the first node is inserted between the second node and the third node, the second node and the third node may be doubly-linked nodes with each other. The processor 213 may determine whether a "first L2P table including the first LPN" is the same as a "second L2P table including the second LPN" based on the number of pages in an L2P table included in one or more L2P tables. The processor 213 may determine whether a "first L2P table including the first LPN" is the same as a "third L2P table including the third LPN" based on the number of pages in an L2P table included in one or more L2P tables. When the first L2P table is different from both the second L2P table and the third L2P table, the processor 213 may increment the comparison-based dirty L2P table counter by 1. When the first L2P table is the same as at least one of the second L2P table and the third L2P table, the processor 213 may maintain (without incrementing) the comparison-based dirty L2P table counter (e.g., bypass the increment of the comparison-based dirty L2P table counter). The second LPN is the maximum value of the closest LPN group among the LPNs less than the first LPN. The LPN group may include at least one consecutive LPN. In one example, the second LPN is the maximum value of the closest LPN group among a plurality of LPN groups among the LPNs less than the first LPN. The third LPN is the value closest to the first LPN among the LPNs greater than the first LPN. In one example, the third LPN is the minimum value of the closest LPN group among the LPNs greater than the first LPN. The first node, the second node, and the third node may have a doubly-linked list structure. Based on the first node, the second node may be the previous node, and the third node may be the next node. The first node, the second node, and the third node may be doubly-linked with each other. Specifically, the first node and the second node may be doubly-linked with each other and the second node and the third node may be doubly-linked with each other. In some embodiments, the first node, the second node, and the third node may have a singly-linked list structure and a tree structure. The processor 213 may determine whether the first L2P table is the same as the second L2P table by comparing whether the quotient obtained by dividing the first LPN by the number of pages is the same as the quotient obtained by dividing the second LPN by the number of pages.The processor 213 can determine whether the first L2P table is the same as the third L2P table by comparing whether "the quotient obtained by dividing the first LPN by the number of pages" is the same as "the quotient obtained by dividing the third LPN by the number of pages". Here, the number of pages represents the number of pages included in the L2P table. The number of pages included in each of the first L2P table to the third L2P table can be all the same. When the first LPN is already valid before inserting the first node, the processor 213 can maintain (without increasing) the dirty L2P table counter based on the comparison. The processor 213 can flush one or more L2P tables to the non-volatile memory 220 based on at least one of the number of one or more L2P tables and the comparison-based L2P counter value. For example, when the comparison-based L2P counter value is equal to or greater than the threshold, the processor 213 can flush one or more L2P tables to the non-volatile memory 220. The second node can include information about "the number of consecutive LPNs in the LPN group closest to the first LPN among the LPN groups less than the first LPN". The third node can include information about "the number of consecutive LPNs in the LPN group closest to the first LPN among the LPN groups greater than the first LPN". The processor 213 can identify the second LPN by identifying the minimum LPN of the LPN group closest to the first LPN among the LPNs less than the first LPN and the information about the number of consecutive LPNs.

[0033] The host-storage device system 10 can reduce the capacity of the SRAM for metadata context management.

[0034] The storage controller 210 maintains or increases the comparison-based dirty L2P table counter by comparing the node corresponding to the newly inserted LPN with both the previous node and the next node. Therefore, compared with using a bitmap-based dirty L2P table counter, the storage controller 210 significantly reduces the amount of SRAM memory required.

[0035] The storage controller 210 can effectively count the mapping tables including updated / discarded LPNs.

[0036] The storage controller 210 can reduce the overhead of counting the mapping tables including updated / discarded LPNs.

[0037] The storage controller 210 can reduce the required SRAM capacity by using a comparison-based dirty L2P table counter. Therefore, the storage controller 210 can manage the L2P table and the L2P table counter when the on-domain SRAM is not always operating.

[0038] Figure 2 An example of the storage controller is shown.

[0039] may refer to Figure 1 description Figure 2 , and repeated descriptions may be omitted. Refer to Figure 2 , the storage controller 210 may include a host interface HOST I / F 211, a memory interface MEMORY I / F 212, and a central processing unit (CPU) 213a. In addition, the storage controller 210 may further include a flash translation layer (FTL) 214, an SRAM 230, a packet manager PCK MNG 215, a buffer memory BUFMEM 216, an error correction code (ECC) engine ECC ENG 217, and an advanced encryption standard (AES) engine AES ENG 218.

[0040] The storage controller 210 may further include a working memory into which the FTL 214 is loaded, and the CPU 213a may execute the FTL 214 to control data write and read operations for the non-volatile memory 220.

[0041] The host interface HOST I / F 211 may send packets to the host 100 and receive packets from the host 100. Packets sent from the host 100 to the host interface HOST I / F 211 may include commands, data to be written to the non-volatile memory 220, etc., and packets sent from the host interface HOST I / F 211 to the host 100 may include responses to commands, data read from the non-volatile memory 220, etc. The memory interface MEMORY I / F 212 may send data to be written to the non-volatile memory 220 to the non-volatile memory 220, or receive data read from the non-volatile memory 220. The memory interface MEMORY I / F 212 may be implemented to conform to a standard protocol (such as Toggle or Open NAND Flash Interface (ONFI)).

[0042] The FTL 214 may include firmware or software driven by the storage controller 210. The FTL 214 may perform some functions (such as address mapping, wear leveling, and garbage collection). The address mapping operation includes the operation of changing a logical address received from the host 100 into a physical address for actually storing data in the non-volatile memory 220. The wear leveling operation is a technique for preventing excessive degradation of a specific block by allowing uniform use of blocks in the non-volatile memory 220. For example, the wear leveling operation may be implemented by a firmware technique that balances the erase counts of physical blocks. The garbage collection operation is a technique for ensuring available capacity in the non-volatile memory 220 by copying valid data of a block to a new block and then erasing the existing block.

[0043] The packet manager PCK MNG 215 can generate packets that conform to the protocol of the interface negotiated with the host 100, or parse various information based on the packets received from the host 100. In addition, the buffer memory BUF_MEM 216 can temporarily store data to be recorded to the non-volatile memory 220 or data to be read from the non-volatile memory 220. The buffer memory BUF_MEM 216 can be set within the storage controller 210, but can also be set outside the storage controller 210.

[0044] The ECC engine 217 can perform error detection and correction functions on the read data read from the non-volatile memory 220. More specifically, the ECC engine 217 can generate parity bits for the write data to be written to the non-volatile memory 220, and the parity bits generated in this way can be stored in the non-volatile memory 220 together with the write data. When data is read from the non-volatile memory 220, the ECC engine 217 can correct the errors of the read data by using the parity bits read from the non-volatile memory 220 together with the read data, and can output the read data after error correction.

[0045] The AES engine 218 can perform at least one of an encryption operation and a decryption operation on the data input to the storage controller 210 by using a symmetric key algorithm.

[0046] The SRAM 230 can store the meta context 240. The meta context 240 can be referred to as metadata, and can include L2P table information and a comparison-based dirty L2P table counter. The storage controller 210 can flush the meta context 240 to the non-volatile memory 220 by using the FTL 214.

[0047] Figure 3 is a diagram for showing an example of the L2P table.

[0048] can be referred to Figure 1 description Figure 3 , and the repeated description can be omitted. The L2P table information includes mapping information between the LPN and the physical page number (PPN). Specifically, the L2P table information can include mapping information between the physical address within the non-volatile memory 220 and the logical address corresponding to the physical address. The L2P table information including the mapping table can also be referred to as mapping table information.

[0049] Generally, NAND flash memory devices do not support overwrite operations. To modify data, the NAND flash memory device can program the data of a new page into an idle page existing in the corresponding block or another block, and perform address mapping on the new page by using the FTL. As a result, the page programmed with the data of the previous page can become an invalid page, and the page programmed with the data of the new page can become a valid page. Therefore, valid pages and invalid pages can coexist within one block.

[0050] Referring to Figure 3 , the L2P table on the left side includes mapping information between 1024 LPNs and PPNs. For example, LPN0 can be mapped to PPN0, LPN1 and LPN2 may not be mapped to physical addresses, and LPNs 1021 to 1023 can be mapped to PPNs 1080 to 1082 respectively. The mapping information can be modified according to the request of host 100. For example, the storage controller 210 can update LPN2 to be mapped to PPN50 according to the request of host 100. In another example, the storage controller 210 can discard the mapping between LPN1021 and PPN1080 according to the request of host 100. That is to say, the modification of the mapping information can include at least one of updating the mapping and discarding the mapping. When there is a modification to at least one of the 1024 pages in the L2P table, the dirty L2P table count can increase. In Figure 3 , since there are modifications to LPN2 and LPN1021, the dirty L2P table count can increase.

[0051] Figure 4 is a diagram showing an example of the dirty L2P table count.

[0052] It can be referred to Figure 1 to describe Figure 4 . As described above in Figure 3 , there can be a modification to at least one of multiple pages in the L2P table. When at least one page has been modified, the corresponding L2P table can be a modified L2P table. The dirty L2P table count represents the number of modified L2P tables. In other words, the dirty L2P table count represents the number of L2P tables among multiple L2P tables that include the modified pages.

[0053] Referring to Figure 4 , each of L2P table #0, L2P table #1, and L2P table #2 includes mapping information of pages. In Figure 4 , L2P table #0 can include mapping information corresponding to logical page numbers LPN0 to LPN1023, L2P table #1 can include mapping information corresponding to logical page numbers LPN1024 to LPN2047, and L2P table #2 can include mapping information corresponding to logical page numbers LPN2048 to LPN3071. The boxes filled with dotted lines indicate the modified and valid pages. For example, referring to Figure 4 the L2P table at the top of, L2P table #0 has two modified pages, L2P table #1 has no modified pages, and L2P table #2 has one modified page. Since a total of two L2P tables (L2P table #0 and L2P table #2) include the modified pages, the value of the dirty L2P table count is equal to 2. Thereafter, the pages of L2P table #1 can be modified according to the request of host 100.Figure 4 The L2P table #1 at the bottom indicates that the page of the L2P table #1 has been modified. In this case, since the three L2P tables include the modified page, the value of the dirty L2P table count may be equal to 3.

[0054] The storage controller 210 can determine whether the dirty L2P table count increases by comparing the newly modified first LPN with the existing changed LPN. Therefore, in the present disclosure, the dirty L2P table counter used by the storage controller 210 is referred to as a comparison-based dirty L2P table counter.

[0055] Figure 5 An example of a method for managing a comparison-based dirty L2P table counter is shown.

[0056] Reference may be made to Figure 1 description Figure 5 , and repeated descriptions may be omitted. It is assumed that the L2P table information includes 1024 mapping information.

[0057] Reference Figure 5 , the second LPN LPN200 is an existing modified page, and the storage controller 210 can newly modify the first LPN LPN1600 according to the request of the host 100. Since the second LPN LPN200 is less than the first LPN LPN1600, the second LPN LPN200 can be referred to as the previous LPN. The first LPN LPN1600 can be referred to as the current LPN. Obviously, the first LPN LPN1600 and the second LPN LPN200 can be different pages, and are not limited to the above embodiments of the second LPN LPN200 and the first LPN LPN1600.

[0058] Reference Figure 5 , when only the second node already exists, the storage controller 210 can insert the first node. The second node corresponds to the second LPN LPN200. Therefore, the second node can be the previous node of the first node. The second LPN LPN200 is an existing modified LPN and is located in the L2P table #0. The second node may include the second LPN LPN200, the second PPN PPN200 mapped to the second LPN LPN200, and information about the number CNT_CSP of consecutive modified LPNs from the second LPN LPN200. Since the value of the number CNT_CSP of consecutive modified LPNs from the second LPN LPN200 is equal to 1, one second LPN LPN200 is a modified LPN.

[0059] The first LPN, LPN1600, is a newly modified LPN according to the request of the host 100 and is located in the L2P table #1. The first node may include the first LPN, LPN1600, the first PPN, PPN1600, mapped to the first LPN, LPN1600, and information on the number of consecutive modified LPNs, CNT_CSP, from the first LPN, LPN1600. Since the value of the number of consecutive modified LPNs, CNT_CSP, from the first LPN, LPN1600, is equal to 1, the first LPN, LPN1600, is a modified LPN.

[0060] The storage controller 210 may use a data structure for comparing the first node with the second node. In some embodiments, when the second LPN, LPN200, already exists and the storage controller 210 newly modifies the first LPN, LPN1600, the storage controller 210 may insert the first node and may doubly link the first node to the second node. That is, the first node and the second node may have a doubly linked list structure. According to some embodiments, when the second LPN, LPN200, already exists and the storage controller 210 newly modifies the first LPN, LPN1600, the storage controller 210 may insert the first node and may link the first node and the second node to have a tree structure and a singly linked list structure.

[0061] The storage controller 210 may determine whether the L2P table #0 including the second LPN, LPN200, is the same as the L2P table #1 including the first LPN, LPN1600. For example, the storage controller 210 may determine whether "the quotient obtained by dividing the second LPN, LPN200, by the number of pages (1024) included in the L2P table" is the same as "the quotient obtained by dividing the first LPN, LPN1600, by the number of pages (1024) included in the L2P table". The quotient obtained by dividing the second LPN, LPN200, by 1024 is equal to 0, and the quotient obtained by dividing the first LPN, LPN1600, by 1024 is equal to 1. Since the quotients are different from each other, the storage controller 210 may determine that the L2P table #0 including the second LPN, LPN200, is different from the L2P table #1 including the first LPN, LPN1600. Therefore, the storage controller 210 may increment the comparison-based dirty L2P table counter by 1. Previously, the second LPN, LPN200, was modified, and the comparison-based dirty L2P table counter was incremented from 0 to 1. Therefore, when the first LPN, LPN1600, is newly modified, the storage controller 210 may increment the comparison-based dirty L2P table counter from 1 to 2.

[0062] Figure 6 An example of a method for managing the comparison-based dirty L2P table counter is shown.

[0063] Reference may be made to Figure 1 and Figure 5 for a description Figure 6 , and repeated descriptions may be omitted. Assume that the L2P table includes 1024 pages. Referring to Figure 6 , the third LPN LPN3000 is an existing modified page, and the storage controller 210 may newly modify the first LPN LPN1600 according to a request from the host 100. Since the third LPN LPN3000 is greater than the first LPN LPN1600, the third LPN LPN3000 may be referred to as the next LPN. Since the second LPN LPN200 is less than the first LPN LPN1600, the second LPN LPN200 may be referred to as the previous LPN. The first LPN LPN1600 may be referred to as the current LPN.

[0064] Referring to Figure 6 , when only the third node already exists, the storage controller 210 may insert the first node. The third node corresponds to the third LPN LPN3000. Thus, the third node may be the next node of the first node. The third LPN LPN3000 is an existing modified LPN and is located in L2P table #2. The third node may include the third LPN LPN3000, the third PPN PPN3000 mapped to the third LPN LPN3000, and information about the number CNT_CSP of consecutive modified LPNs starting from the third LPN LPN3000. Since the value of the number CNT_CSP of consecutive modified LPNs starting from the third LPN LPN3000 is equal to 1, one third LPN LPN3000 is a modified LPN.

[0065] The first LPN LPN1600 is a newly modified LPN according to a request from the host 100 and is located in L2P table #1.

[0066] The storage controller 210 may use a data structure for comparing the first node with the third node. In some embodiments, when the third LPN LPN3000 already exists and the storage controller 210 newly modifies the first LPN LPN1600, the storage controller 210 may insert the first node and may doubly link the first node to the third node. That is, the first node and the third node may have a doubly linked list structure. According to some embodiments, when the third LPN LPN3000 already exists and the storage controller 210 newly modifies the first LPN LPN1600, the storage controller 210 may insert the first node and may link the first node and the third node to have a tree structure and a singly linked list structure.

[0067] The storage controller 210 may determine whether the L2P table #2 including the third LPN LPN3000 is the same as the L2P table #1 including the first LPN LPN1600. For example, the storage controller 210 may determine whether "the quotient obtained by dividing the first LPN LPN1600 by the number of pages (1024) included in the L2P table" is the same as "the quotient obtained by dividing the third LPN LPN3000 by the number of pages (1024) included in the L2P table". The quotient obtained by dividing the first LPN LPN1600 by 1024 is equal to 1, and the quotient obtained by dividing the third LPN LPN3000 by 1024 is equal to 2. Since the quotients are different from each other, the storage controller 210 may determine that the L2P table #1 including the first LPN LPN1600 is different from the L2P table #2 including the third LPN LPN3000. Therefore, the storage controller 210 may increment the comparison-based dirty L2P table counter by 1. Previously, the third LPN LPN3000 was modified, and the comparison-based dirty L2P table counter was incremented from 0 to 1. Therefore, when the first LPN LPN1600 is newly modified, the storage controller 210 may increment the comparison-based dirty L2P table counter from 1 to 2.

[0068] Figure 7 An example of a method for managing a comparison-based dirty L2P table counter is shown.

[0069] Reference may be made to Figure 1 、 Figure 5 and Figure 6 for a description Figure 7 and repeated descriptions may be omitted. Assume that the L2P table includes 1024 pages. Referring to Figure 7 , the second LPN LPN200 and the third LPN LPN3000 are existing modified pages, and the storage controller 210 may newly modify the first LPN LPN1600 according to a request from the host 100. Since the second LPN LPN200 is less than the first LPN LPN1600, the second LPN may be referred to as the previous LPN. Since the third LPN LPN3000 is greater than the first LPN LPN1600, the third LPN may be referred to as the next LPN. The first LPN LPN1600 may be referred to as the current LPN.

[0070] Refer to Figure 7, when the second node and the third node already exist, the storage controller 210 can insert the first node between the second node and the third node. The storage controller 210 can identify the previous node of the first node and the next node of the first node based on the size of the LPN and the structure of the node. In some embodiments, the second node and the third node are linked to each other based on a doubly linked list structure. To insert the first node, the storage controller 210 can identify a second LPN LPN200 that is less than the first LPN LPN1600, a third LPN LPN3000 that is greater than the first LPN LPN1600, and the doubly linked list structure of the second node and the third node, and then can insert the first node between the second node and the third node. According to some embodiments, the second node and the third node are linked to each other based on a tree structure and a singly linked list structure. To insert the first node, the storage controller 210 can identify a second LPN LPN200 that is less than the first LPN LPN1600, a third LPN LPN3000 that is greater than the first LPN LPN1600, and the singly linked list structure and the tree structure of the second node and the third node, and then can insert the first node between the second node and the third node. The first node corresponds to the first LPN LPN1600, and the third node corresponds to the third LPN LPN3000. Therefore, the second node can be the previous node of the first node, and the third node can be the next node of the first node.

[0071] That is to say, the storage controller 210 can use a data structure for comparing the first node with the second node and the third node. In some embodiments, when the second LPN LPN200 and the third LPN LPN3000 already exist and the storage controller 210 newly modifies the first LPN LPN1600, the storage controller 210 can insert the first node and can doubly link each of the second node and the third node to the first node. That is to say, the first node to the third node can have a doubly linked list structure. According to some embodiments, when the second LPN LPN200 and the third LPN LPN3000 already exist and the storage controller 210 newly modifies the first LPN LPN1600, the storage controller 210 can insert the first node and can link the first node to the third node to have a tree structure and a singly linked list structure.

[0072] The storage controller 210 may determine whether the L2P table #2 including the third LPN LPN3000 is the same as the L2P table #1 including the first LPN LPN1600. The storage controller 210 may determine whether the L2P table #0 including the second LPN LPN200 is the same as the L2P table #1 including the first LPN LPN1600. When the L2P table #1 is the same as at least one of the L2P table #2 and the L2P table #0, the storage controller 210 may maintain (without incrementing) the comparison-based dirty L2P table counter. Since the L2P table #1 is different from both the L2P table #0 and the L2P table #2, the storage controller 210 may increment the comparison-based dirty L2P table counter by 1.

[0073] For example, the storage controller 210 may determine whether "the quotient (1) obtained by dividing the first LPN LPN1600 by 1024" is the same as at least one of "the quotient (2) obtained by dividing the third LPN LPN3000 by 1024" and "the quotient (0) obtained by dividing the second LPN LPN200 by 1024". Since the quotients are all different from each other, the storage controller 210 may increment the comparison-based dirty L2P table counter by 1.

[0074] Figure 8 An example of a method for managing the comparison-based dirty L2P table counter is shown.

[0075] Reference may be made to Figure 1 and Figures 5 to 7 for a description Figure 8 , and the repeated description may be omitted. Assume that the L2P table includes 1024 pages. Referring to Figure 8 , the second LPN LPN200 and the third LPN LPN3000 are existing modified pages, and the storage controller 210 may newly modify the first LPN LPN2100 according to a request from the host 100. Since the third LPN LPN3000 is greater than the first LPN LPN2100, the third LPN may be referred to as the next LPN. The first LPN LPN2100 may be referred to as the current LPN.

[0076] Referring to Figure 8 , when the second node and the third node already exist, the storage controller 210 may insert the first node between the second node and the third node. The storage controller 210 may identify the previous node of the first node and the next node of the first node based on the size of the LPN and the structure of the nodes.

[0077] That is, the storage controller 210 may use a data structure for comparing the first node with the second and third nodes. In some embodiments, when the second LPN LPN200 and the third LPN LPN3000 already exist and the storage controller 210 newly modifies the first LPN LPN2100, the storage controller 210 may insert the first node and may doubly link each of the second and third nodes to the first node. That is, the first to third nodes may have a doubly linked list structure. According to some embodiments, when the second LPN LPN200 and the third LPN LPN3000 already exist and the storage controller 210 newly modifies the first LPN LPN2100, the storage controller 210 may insert the first node and may link the first node to the third node to have a tree structure and a singly linked list structure.

[0078] The storage controller 210 may determine whether the L2P table #2 including the third LPN LPN3000 is the same as the L2P table #2 including the first LPN LPN2100. The storage controller 210 may determine whether the L2P table #0 including the second LPN LPN200 is the same as the L2P table #2 including the first LPN LPN2100. Since the L2P table #2 is the same as at least one of the L2P table #0 and the L2P table #2, the storage controller 210 may maintain a comparison-based dirty L2P table counter.

[0079] Specifically, because "the quotient (2) obtained by dividing the first LPN LPN2100 by 1024" is the same as "the quotient (2) obtained by dividing the third LPN LPN3000 by 1024" among "the quotient (2) obtained by dividing the third LPN LPN3000 by 1024" and "the quotient (0) obtained by dividing the second LPN LPN200 by 1024", the storage controller 210 may maintain a comparison-based dirty L2P table counter.

[0080] Figure 9 An example of a method for managing a comparison-based dirty L2P table counter is shown.

[0081] Reference may be made to Figure 1 and Figures 5 to 8 description Figure 9 and repetitive descriptions may be omitted. Assume that the L2P table includes 1024 pages.

[0082] Reference Figure 9, the second LPN LPN1100 and the third LPN LPN3000 are existing modified pages, and the storage controller 210 can newly modify the first LPN LPN1600 according to the request of the host 100. Since the second LPN LPN1100 is smaller than the first LPN LPN1600, the second LPN LPN1100 can be referred to as the previous LPN. Since the third LPN LPN3000 is larger than the first LPN LPN1600, the third LPN LPN3000 can be referred to as the next LPN. The first LPN LPN1600 can be referred to as the current LPN.

[0083] Referring to Figure 9 , when the second node and the third node already exist, the storage controller 210 can insert the first node between the second node and the third node. The first node corresponds to the first LPN LPN1600. The third node corresponds to the third LPN LPN3000. The second node corresponds to the LPN200 and can be associated with the second LPN LPN1100. Therefore, the second node can be the previous node of the first node, and the third node can be the next node of the first node. The second node may include information about the number of consecutive pages CNT_CSP from the LPN200. The value of the number of consecutive pages CNT_CSP from the LPN200 is equal to 901. Therefore, the existing modified pages exist continuously from the LPN200 to the second LPN LPN1100.

[0084] The storage controller 210 can identify the information about the number of consecutive pages CNT_CSP from the LPN200 of the second node and identify the second LPN LPN1100 that is closest to the first LPN LPN1600 among the consecutive LPNs. That is, the storage controller 210 can identify the largest second LPN LPN1100 among the consecutive LPNs. As an example, the storage controller 210 can identify the second LPN LPN1100 based on the smallest LPN LPN200 in the LPN group that is closest to the first LPN LPN1600 among the LPNs smaller than the first LPN LPN1600 and the information about the number of consecutive LPNs (CNT_CSP = 901). When the number of consecutive pages CNT_CSP from the LPN200 of the second node is equal to 1, the second node can be associated with the LPN200 and can correspond to the LPN200.

[0085] The storage controller 210 can identify the previous node of the first node and the next node of the first node based on the size of the LPN and the structure of the nodes. In some embodiments, the second node and the third node are linked to each other based on a doubly linked list structure. To insert the first node, the storage controller 210 can identify a second LPN LPN1100 that is less than the first LPN LPN1600, a third LPN LPN3000 that is greater than the first LPN LPN1600, and the doubly linked list structure of the second node and the third node, and then can insert the first node between the second node and the third node. According to some embodiments, the second node and the third node are linked to each other based on a tree structure and a singly linked list structure. To insert the first node, the storage controller 210 can identify a second LPN LPN1100 that is less than the first LPN LPN1600, a third LPN LPN3000 that is greater than the first LPN LPN1600, and the singly linked list structure and the tree structure of the second node and the third node, and then can insert the first node between the second node and the third node.

[0086] The storage controller 210 can determine whether the L2P table #2 including the third LPN LPN3000 is the same as the L2P table #1 including the first LPN LPN1600. The storage controller 210 can determine whether the L2P table #1 including the second LPN LPN1100 is the same as the L2P table #1 including the first LPN LPN1600. Since the L2P table #1 is the same as at least one of the L2P table #0 and the L2P table #1, the storage controller 210 can maintain (without incrementing) the dirty L2P table counter based on the comparison.

[0087] For example, the storage controller 210 can determine whether "the quotient (1) obtained by dividing the first LPN LPN1600 by 1024" is the same as at least one of "the quotient (2) obtained by dividing the third LPN LPN3000 by 1024" and "the quotient (1) obtained by dividing the second LPN LPN1100 by 1024". Since "the quotient (1) obtained by dividing the first LPN LPN1600 by 1024" is the same as at least one of "the quotient (2) obtained by dividing the third LPN LPN3000 by 1024" and "the quotient (1) obtained by dividing the second LPN LPN1100 by 1024", the storage controller 210 can maintain the dirty L2P table counter based on the comparison.

[0088] Figure 10 An example of a method of operating a storage controller is shown. Figure 11 An example of L2P table identity determination is shown.

[0089] Reference may be made to Figure 1 and Figures 5 to 9 description Figure 10and Figure 11 , and repeated descriptions may be omitted.

[0090] Referring to Figure 10 , in step S101, the storage controller 210 may receive a request from the host for modifying the first LPN. The modification may include updating and discarding.

[0091] In step S103, the storage controller 210 may insert a first node corresponding to the first LPN between a second node associated with a second LPN and a third node corresponding to (or associated with) a third LPN. In some embodiments, the first node, the second node, and the third node may have a doubly linked list structure. According to some embodiments, the first node, the second node, and the third node may simultaneously have a singly linked list structure and a tree structure. The storage controller 210 may find the second node and the third node through tree traversal.

[0092] The second LPN is the maximum value in the LPN group that is the closest to the first LPN among the LPNs less than the first LPN. The LPN group may include at least one consecutive LPN. For example, in the description given in reference to Figure 9 , LPN200 to LPN1100 are the LPN group that is the closest to the first LPN, and the largest LPN here is LPN1100. The third LPN is the minimum value among the LPNs greater than the first LPN. Assume that both the LPN group and the third LPN are valid pages.

[0093] In addition, the storage controller 210 may perform an invalidation check on the first LPN. For example, when the first LPN is already valid before inserting the first node, the storage controller 210 may not increment the comparison-based dirty L2P table counter (e.g., may bypass the increment of the comparison-based dirty L2P table counter).

[0094] The storage controller 210 may identify the second node and the third node based on the first LPN and the structures of the second node and the third node. In addition, the second node may include information about the number of consecutive LPNs in the LPN group that is the closest to the first LPN among the LPNs less than the first LPN. The storage controller 210 may identify the second LPN based on the smallest LPN in the LPN group that is the closest to the first LPN among the LPNs less than the first LPN and the information about the number of consecutive LPNs.

[0095] In step S105, the storage controller 210 may determine whether the "first L2P table including the first LPN" is the same as the "second L2P table including the second LPN" based on the number of pages in one L2P table included in one or more L2P tables. For example, referring to Figure 11, in step S105a, the storage controller 210 may determine whether "the quotient obtained by dividing the first LPN by the number of pages of the L2P table" is the same as "the quotient obtained by dividing the second LPN by the number of pages".

[0096] In step S107, the storage controller 210 may determine whether "the first L2P table including the first LPN" is the same as "the third L2P table including the third LPN" based on the number of pages in one of the one or more L2P tables. For example, referring to Figure 11 , in step S107a, the storage controller 210 may determine whether "the quotient obtained by dividing the first LPN by the number of pages" is the same as "the quotient obtained by dividing the third LPN by the number of pages".

[0097] In step S109, the storage controller 210 may identify whether the first L2P table is the same as at least one of the second L2P table and the third L2P table. For example, referring to Figure 11 , in step S109a, the storage controller 210 may determine whether "the quotient obtained by dividing the first LPN by the number of pages of the L2P table" is the same as at least one of "the quotient obtained by dividing the third LPN by the number of pages" and "the quotient obtained by dividing the second LPN by the number of pages".

[0098] In step S111, when "the quotient obtained by dividing the first LPN by the number of pages of the L2P table" is different from both "the quotient obtained by dividing the third LPN by the number of pages" and "the quotient obtained by dividing the second LPN by the number of pages", the storage controller 210 may increment the comparison-based dirty L2P table counter by 1.

[0099] In step S113, when "the quotient obtained by dividing the first LPN by the number of pages of the L2P table" is the same as at least one of "the quotient obtained by dividing the third LPN by the number of pages" and "the quotient obtained by dividing the second LPN by the number of pages", the storage controller 210 may maintain the comparison-based dirty L2P table counter.

[0100] In some embodiments, the storage controller 210 may write the L2P table to the non-volatile memory 220 based on at least one of the number of L2P tables and the comparison-based L2P counter value. By writing the L2P table to the non-volatile memory 220, the storage controller 210 may make the L2P table stored in the non-volatile memory 220 the same as the modified L2P table in the SRAM 230.

[0101] Figure 12 An example of a method of operating a storage controller is shown.

[0102] Reference can be made to Figure 1 and Figures 5 to 9 description Figure 12 and repeated descriptions can be omitted.

[0103] The storage controller 210 can modify the first LPN according to the request of the host 100. The storage controller 210 can determine whether to increase the comparison-based dirty L2P table counter according to the modification of the first LPN as follows. The first node corresponds to the first LPN.

[0104] In step S201, the storage controller 210 can determine whether the first node is valid. When the first node is invalid, the storage controller 210 may not increase the comparison-based dirty L2P table counter.

[0105] In step S203, when the first node is valid, the storage controller 210 can identify whether the previous node and the next node exist.

[0106] In step S205, when both the previous node and the next node exist, the storage controller 210 can determine whether the L2P table including the first LPN is the same as the L2P tables related to each of the previous node (the second node) and the next node (the third node). When the L2P table including the first LPN is different from both the L2P table including the second LPN and the L2P table including the third LPN, the storage controller 210 can increase the comparison-based dirty L2P table counter.

[0107] In step S207, when only one of the previous node and the next node exists, the storage controller 210 can determine whether the L2P table including the first LPN is the same as the L2P table related to the existing node. For example, when the previous node exists, when the L2P table including the first LPN is different from the L2P table including the second LPN, the storage controller 210 can increase the comparison-based dirty L2P table counter.

[0108] In step S209, when neither the previous node nor the next node exists, the storage controller 210 can increase the comparison-based dirty L2P table counter by 1.

[0109] Figure 13 An example of the operation process of the computing device is shown.

[0110] Refer to Figure 13, the SSD system 1000 may include a host 1100 and an SSD 1200. The SSD 1200 may exchange signals (SGL) with the host 1100 through a signal connector and receive power (PWR) through a power connector. The SSD 1200 may include a memory controller 1210, an auxiliary power supply 1220, and a plurality of memory devices (e.g., a first flash memory, a second flash memory, and an nth flash memory) 1230, 1240, and 1250.

[0111] The plurality of memory devices 1230, 1240, and 1250 are connected to the memory controller 1210 through channels Ch1 to Chn. According to some embodiments, the memory controller 1210 may perform operations of loading, updating, and storing an L2P table. In addition, the memory controller 1210 may maintain or increase a comparison-based dirty L2P table counter by comparing a node corresponding to a newly inserted LPN with each of a previous node and a next node.

[0112] Figure 14 An example of a block diagram showing a Universal Flash Storage (UFS) system is shown.

[0113] The UFS system 2000 is a system compliant with the UFS standard released by the Joint Electron Device Engineering Council (JEDEC) and may include a UFS host 2100, a UFS device 2200, and a UFS interface 2300. Figure 1 The above description of the host-storage device system 10 may also be applied to Figure 14 to the extent that it does not conflict with the following description of Figure 14 the UFS system 2000.

[0114] Referring to Figure 14 , the UFS host 2100 and the UFS device 2200 may be interconnected through the UFS interface 2300. The UFS host 2100 may be implemented as part of an application processor.

[0115] The UFS host 2100 may perform Figure 1 and Figure 2 the operations of the host 100, and the UFS device 2200 may perform Figure 1 and Figure 2 the operations of the storage device 200. The UFS host 2100 may perform the operations of the above host 100. The UFS device 2200 may perform the operations of the above storage device 200.

[0116] The UFS host 2100 may include a UFS host controller 2110, an application 2120, a UFS driver 2130, a host memory 2140, and a UFS Interconnect (UIC) layer 2150. The UFS device 2200 may include a UFS device controller 2210, a non-volatile storage device 2220, a storage interface 2230, a device memory 2240, a UIC layer 2250, and a regulator 2260. The non-volatile storage device 2220 may be composed of a plurality of memory cells 2221, and the memory cells 2221 may include 2D-structured or 3D-structured V-NAND flash memories, but may also include different types of non-volatile memories (such as PRAM and / or RRAM). The UFS device controller 2210 may be connected to the non-volatile storage device 2220 through the storage interface 2230. The storage interface 2230 may be implemented to conform to a standard protocol (such as Toggle or ONFI).

[0117] The application 2120 may represent a program intended to communicate with the UFS device 2200 to use the functions of the UFS device 2200. The application 2120 may send an Input-Output Request (IOR) to the UFS driver 2130 for input / output to the UFS device 2200. The Input-Output Request (IOR) may represent a data read request, a write request, and / or a discard request, etc., but is not limited thereto.

[0118] The UFS driver 2130 may manage the UFS host controller 2110 through a UFS-Host Controller Interface (UFS-HCI). The UFS driver 2130 may convert the input / output request generated by the application 2120 into a UFS command defined by the UFS standard, and deliver the converted UFS command to the UFS host controller 2110. One input / output request may be converted into multiple UFS commands. The UFS commands may basically include commands defined by the Small Computer System Interface (SCSI) standard, but may also include commands specific to the UFS standard.

[0119] The UFS host controller 2110 may send the UFS command converted by the UFS driver 2130 to the UIC layer 2250 of the UFS device 2200 through the UIC layer 2150 and the UFS interface 2300. In this process, the UFS host register 2111 of the UFS host controller 2110 may be used as a Command Queue (CQ).

[0120] The UIC layer 2150 on the UFS host 2100 side may include a Mobile Industry Processor Interface (MIPI) Physical Layer (M-PHY) 2151 and MIPI UniPro 2152, and the UIC layer 2250 on the UFS device 2200 side may further include an MIPI M-PHY 2252 and MIPI UniPro 2251.

[0121] The UFS interface 2300 may include a line for transmitting a reference clock REF_CLK, a line for transmitting a hardware reset signal RESET_n of the UFS device 2200, a pair of lines for transmitting a pair of differential input signals DIN_t and DIN_c, and a pair of lines for transmitting a pair of differential output signals DOUT_t and DOUT_c.

[0122] The frequency value of the reference clock provided from the UFS host 2100 to the UFS device 2200 may include one of four values of 19.2 MHz, 26 MHz, 38.4 MHz, and 52 MHz, but is not necessarily limited thereto. The UFS host 2100 may even modify the frequency value of the reference clock during operation (i.e., even when data transmission and reception are performed between the UFS host 2100 and the UFS device 2200). The UFS device 2200 may generate clocks of various frequencies according to the reference clock provided from the UFS host 2100 by using a phase-locked loop (PLL) or the like. In addition, the UFS host 2100 may also set the value of the data rate between the UFS host 2100 and the UFS device 2200 by the frequency value of the reference clock. That is, the value of the data rate may be determined according to the frequency value of the reference clock.

[0123] The UFS interface 2300 may support multiple channels, and each channel may be implemented as a differential pair. For example, the UFS interface 2300 may include one or more receiving channels and one or more transmitting channels. Separately, a pair of lines for receiving the differential input signal pair DIN_t and DIN_c may constitute a receiving channel, and a pair of lines for transmitting the differential output signal pair DOUT_t and DOUT_c may constitute a transmitting channel. Although Figure 2 one transmitting channel and one receiving channel are shown, the number of transmitting channels and receiving channels may be changed.

[0124] The receiving channel and the transmitting channel may transmit data in a serial communication method, and the separate structure of the receiving channel and the transmitting channel enables full-duplex communication between the UFS host 2100 and the UFS device 2200. That is, even when receiving data from the UFS host 2100 through the receiving channel, the UFS device 2200 may transmit data to the UFS host 2100 through the transmitting channel. In addition, control data (such as a command from the UFS host 2100 to the UFS device 2200) and user data that the UFS host 2100 intends to store in the non-volatile storage device 2220 of the UFS device 2200 or intends to read from the non-volatile storage device 2220 may be transmitted through the same channel. Therefore, in addition to a pair of receiving channels and a pair of transmitting channels, no separate channel for data transmission needs to be provided between the UFS host 2100 and the UFS device 2200.

[0125] The UFS device controller 2210 of the UFS device 2200 can generally control the operation of the UFS device 2200. The UFS device controller 2210 can manage the non-volatile storage device 2220 through a logical unit (LU) 2211 that serves as a logical data storage unit. For example, the LU 2211 can include logical unit #0 to logical unit #N-1. The number of LUs 2211 can be equal to 8, but is not limited thereto. The UFS device controller 2210 can include an FTL, and can convert the logical data address (e.g., logical block address (LBA)) delivered from the UFS host 2100 into a physical data address (e.g., physical block address (PBA)) by using the address mapping information of the FTL. In the UFS system 2000, the logical blocks for storing user data can have a specific range of sizes. For example, the minimum size of the logical block can be set to 4 kilobytes.

[0126] The UFS device controller 2210 can correspond to Figure 1 and Figure 2 the storage controller 210 of the storage device 200. Therefore, the UFS device controller 2210 can maintain or increase the comparison-based dirty L2P table counter by comparing the node corresponding to the newly inserted LBA with each of the previous node and the next node.

[0127] When a command from the UFS host 2100 is input to the UFS device 2200 through the UIC layer 2250, the UFS device controller 2210 can perform an operation in response to the input command, and send a completion response to the UFS host 2100 when the operation is completed.

[0128] As an example, when the UFS host 2100 intends to store user data in the UFS device 2200, the UFS host 2100 can send a data storage command to the UFS device 2200. When receiving a ready transfer response from the UFS device 2200, the UFS host 2100 can transfer the user data to the UFS device 2200. The UFS device controller 2210 can temporarily store the received user data in the device memory 2240, and store the user data temporarily stored in the device memory 2240 in a selected location of the non-volatile storage device 2220 based on the address mapping information of the FTL.

[0129] As another example, when the UFS host 2100 is intended to read user data stored in the UFS device 2200, the UFS host 2100 may send a data read command to the UFS device 2200. The UFS device controller 2210 that has received the command may read the user data from the non-volatile storage device 2220 based on the data read command, and may temporarily store the read user data in the device memory 2240. During this read process, the UFS device controller 2210 may detect and correct errors in the read user data by using a built-in ECC circuit. Also, the UFS device controller 2210 may send the user data temporarily stored in the device memory 2240 to the UFS host 2100. In addition, the UFS device controller 2210 may further include an AES circuit, and the AES circuit may encrypt or decrypt the data input to the UFS device controller 2210 by using a symmetric key algorithm.

[0130] The UFS host 2100 may store in the UFS host register 2111, which can be used as a command queue, the commands to be sent to the UFS device 2200 in order, and send the commands to the UFS device 2200 in order. At this time, even when a previously sent command is still being processed by the UFS device 2200 (i.e., even before the UFS host 2100 receives a notification that the processing of the previously sent command has been completed by the UFS device 2200), the UFS host 2100 may send the next command waiting in the command queue to the UFS device 2200, and thus, even while processing the previously sent command, the UFS device 2200 may receive the next command from the UFS host 2100. The maximum number (queue depth) of commands that can be stored in such a command queue may be, for example, 32. In addition, the command queue may be implemented in a circular queue type that respectively indicates the start and end of the command sequence stored in the queue through a head pointer and a tail pointer.

[0131] Each of the plurality of memory cells 2221 may include a memory cell array and a control circuit that controls the operation of the memory cell array. The memory cell array may include a two-dimensional memory cell array or a three-dimensional memory cell array. The memory cell array may include a plurality of memory cells, and each memory cell may include a cell that stores one bit of information (single-level cell (SLC)), but may also include a cell that stores two or more bits of information (such as, multi-level cell (MLC), triple-level cell (TLC), and quad-level cell (QLC)). The three-dimensional memory cell array may include vertically oriented vertical NAND strings such that at least one memory cell is disposed above another memory cell.

[0132] Power supply voltages (such as, VCC, VCCQ1, VCCQ2, etc.) can be input to the UFS device 2200. VCC is the main power supply voltage for the UFS device 2200 and can have a value of approximately 2.4V to 3.6V. VCCQ1 is a power supply voltage for supplying a low-range voltage and is mainly used for the UFS device controller 2210 and can have a value of approximately 1.14V to approximately 1.26V. VCCQ2 is a power supply voltage for supplying a voltage range lower than VCC but higher than VCCQ1 and is mainly used for the input / output interface (such as, MIPI M-PHY 2252) and can have a value of approximately 1.7V to approximately 1.95V. The power supply voltages can be supplied to the corresponding components of the UFS device 2200 through the regulator 2260. The regulator 2260 can be implemented as a set of unit regulators, and each unit regulator in the set is connected to a different power supply voltage among the above power supply voltages.

[0133] As described above, embodiments have been disclosed in the drawings and the specification. In this specification, specific terms have been used to describe the embodiments, but this is only for the purpose of explaining the technical concept of the present disclosure and not for limiting the meaning or scope of the present disclosure as set forth in the claims. Therefore, those skilled in the art will understand that various modifications and other equivalent embodiments are feasible. Therefore, the scope of the present disclosure should be defined by the technical spirit of the appended claims.

[0134] Although this specification contains many specific implementation details, these should not be construed as limitations on the scope of any invention or the scope that can be claimed, but rather as descriptions of features specific to particular embodiments of a particular invention. The specific features described in the context of separate embodiments in this specification can also be implemented in combination in a single embodiment. Conversely, the various features described in the context of a single embodiment can also be implemented separately or in any suitable sub-combination in multiple embodiments. Additionally, although the features may be described above as acting in a particular combination, in some cases one or more features from the combination can be excluded from the combination, and the combination can relate to a sub-combination or a variation of a sub-combination.

[0135] Although the present disclosure has been shown and described with reference to embodiments of the present disclosure, it will be understood that various changes in form and detail can be made therein without departing from the spirit and scope of the appended claims.

Claims

1. A method of operating a storage controller, the storage controller storing one or more logical-to-physical tables, the method comprising: receiving a request from a host to modify a first logical page number; inserting a first node between the second node and the third node, the first node corresponding to the first logical page number, the second node associated with the second logical page number, and the third node corresponding to the third logical page number; determining whether a first logical-to-physical table is the same as a second logical-to-physical table based on a number of pages in a logical-to-physical table of the one or more logical-to-physical tables, the first logical-to-physical table comprising a first logical page number and the second logical-to-physical table comprising a second logical page number; determining whether the first logical-to-physical table is the same as a third logical-to-physical table based on the number of pages in the logical-to-physical table of the one or more logical-to-physical tables, the third logical-to-physical table including a third logical page number; as well as Based on the first logical-to-physical table being different from both the second logical-to-physical table and the third logical-to-physical table, a comparison-based dirty logical-to-physical table counter is incremented by 1, The second logical page number is the largest in the logical page number group, the logical page number group is closest to the first logical page number among the multiple logical page number groups, and each logical page number of the multiple logical page number groups is smaller than the first logical page number. The logical page number group includes at least one continuous logical page number. Among the plurality of logical page numbers greater than the first logical page number, the third logical page number is the smallest, and The first node, the second node and the third node have a double linked list structure.

2. The method of claim 1, further comprising: Incrementing of a compare-based dirty logical-to-physical table counter is bypassed based on the first logical-to-physical table being identical to at least one of the second logical-to-physical table and the third logical-to-physical table.

3. The method of claim 1, wherein: The step of determining whether the first logical-to-physical table is the same as the second logical-to-physical table comprises: determining whether a first quotient is the same as a second quotient, the first quotient being obtained based on dividing the first logical page number by the number of pages, the second quotient being obtained based on dividing the second logical page number by the number of pages, and The step of determining whether the first logical-to-physical table is the same as the third logical-to-physical table includes determining whether the first quotient is the same as a third quotient obtained by dividing the third logical page number by the number of pages.

4. The method of claim 1, further comprising: Based on the first logical page number being valid before the first node is inserted, the compare-based incrementing of the dirty logical-to-physical table counter is bypassed.

5. The method of claim 1, further comprising: The one or more logical-to-physical tables are flushed to a non-volatile memory based on at least one of a number of tables in the one or more logical-to-physical tables and based on the compared logical-to-physical counter value.

6. The method according to any one of claims 1 to 5, wherein: The second node includes information about the number of consecutive logical page numbers of the logical page number group.

7. The method of claim 6, further comprising: A second logical page number is identified based on the minimum logical page number of the logical page number group and information about the number of consecutive logical page numbers.

8. A method of operating a storage controller, the storage controller storing one or more logical to physical tables, the method comprising: receiving a request from a host to modify a first logical page number; inserting a first node between the second node and the third node, the first node corresponding to the first logical page number, the second node associated with the second logical page number, and the third node associated with the third logical page number; determining whether a first logical-to-physical table is the same as a second logical-to-physical table based on a number of pages in a logical-to-physical table of the one or more logical-to-physical tables, the first logical-to-physical table comprising a first logical page number and the second logical-to-physical table comprising a second logical page number; determining whether the first logical-to-physical table is the same as a third logical-to-physical table based on the number of pages in the logical-to-physical table of the one or more logical-to-physical tables, the third logical-to-physical table including a third logical page number; as well as Based on the first logical-to-physical table being different from both the second logical-to-physical table and the third logical-to-physical table, a comparison-based dirty logical-to-physical table counter is incremented by 1, The second logical page number is the largest in the logical page number group, the logical page number group is closest to the first logical page number among the multiple logical page number groups, and each logical page number of the multiple logical page number groups is smaller than the first logical page number. The logical page number group includes at least one continuous logical page number. Among the plurality of logical page numbers greater than the first logical page number, the third logical page number is the smallest, and The first node, the second node and the third node have a single linked list structure and a tree structure.

9. The method of claim 8, further comprising: Incrementing of a compare-based dirty logical-to-physical table counter is bypassed based on the first logical-to-physical table being identical to at least one of the second logical-to-physical table and the third logical-to-physical table.

10. The method of claim 8, wherein: The step of determining whether the first logical-to-physical table is the same as the second logical-to-physical table comprises: determining whether a first quotient is the same as a second quotient, the first quotient being obtained based on dividing the first logical page number by the number of pages, the second quotient being obtained based on dividing the second logical page number by the number of pages, and The step of determining whether the first logical-to-physical table is the same as the third logical-to-physical table includes determining whether the first quotient is the same as a third quotient obtained by dividing the third logical page number by the number of pages.

11. The method of claim 8, further comprising: Based on the first logical page number being valid before the first node is inserted, the compare-based incrementing of the dirty logical-to-physical table counter is bypassed.

12. The method of claim 8, further comprising: The one or more logical-to-physical tables are flushed to a non-volatile memory based on at least one of a number of tables in the one or more logical-to-physical tables and based on the compared logical-to-physical counter value.

13. The method according to any one of claims 8 to 12, wherein: The second node includes information about the number of consecutive logical page numbers of the logical page number group.

14. The method of claim 13, further comprising: A second logical page number is identified based on the minimum logical page number of the logical page number group and information about the number of consecutive logical page numbers.

15. A storage controller comprising: a static random access memory configured to: store one or more logical-to-physical tables, a comparison-based dirty logical-to-physical table counter, and a plurality of nodes corresponding to a plurality of logical page numbers; as well as processor, The processor is configured as follows: receiving a request from a host to modify a first logical page number; inserting a first node between the second node and the third node, the first node corresponding to the first logical page number, the second node associated with the second logical page number, and the third node corresponding to the third logical page number; determining whether a first logical-to-physical table is the same as a second logical-to-physical table based on a number of pages in a logical-to-physical table of the one or more logical-to-physical tables, the first logical-to-physical table comprising a first logical page number and the second logical-to-physical table comprising a second logical page number; determining whether the first logical-to-physical table is the same as a third logical-to-physical table based on the number of pages in the logical-to-physical table of the one or more logical-to-physical tables, the third logical-to-physical table comprising a third logical page number; and Based on the first logical-to-physical table being different from both the second logical-to-physical table and the third logical-to-physical table, a comparison-based dirty logical-to-physical table counter is increased by 1, The second logical page number is the largest in the logical page number group, the logical page number group is closest to the first logical page number among the multiple logical page number groups, and each logical page number of the multiple logical page number groups is smaller than the first logical page number. The logical page number group includes at least one continuous logical page number. Among the plurality of logical page numbers greater than the first logical page number, the third logical page number is the smallest, and The first node, the second node and the third node have a double linked list structure.

16. The storage controller of claim 15, wherein: The processor is further configured to bypass incrementing of the comparison-based dirty logical-to-physical table counter based on the first logical-to-physical table being identical to at least one of the second logical-to-physical table and the third logical-to-physical table.

17. The storage controller of claim 15, wherein: The processor is configured as: determining whether the first logical-to-physical table is identical to the second logical-to-physical table based on determining whether a first quotient obtained based on dividing a first logical page number by the number of pages is identical to a second quotient obtained based on dividing the second logical page number by the number of pages; and Whether the first logical-to-physical table is identical to the third logical-to-physical table is determined based on determining whether the first quotient is identical to a third quotient obtained based on dividing the third logical page number by the number of pages.

18. The storage controller of claim 15, wherein: The processor is further configured to bypass the compare-based incrementing of the dirty logical-to-physical table counter based on the first logical page number being valid before inserting the first node.

19. The storage controller of claim 15, wherein: The processor is further configured to flush the one or more logical-to-physical tables to a non-volatile memory based on at least one of a number of tables in the one or more logical-to-physical tables and based on the compared logical-to-physical counter value.

20. The storage controller according to any one of claims 15 to 19, wherein: The second node includes: information about the number of consecutive logical page numbers of the logical page number group that is valid and smaller than the first logical page number and is closest to the first logical page number, and The processor is further configured to: identify the second logical page number based on the minimum logical page number of the logical page number group and information about the number of consecutive logical page numbers.

Images