Adjust the block pool size in the storage system
By dynamically adjusting the block pool size in SSD and combining a hybrid controller with SLC and MLC modes, the memory block size adjustment problem in traditional SSD is solved, efficient performance and data durability are achieved, and write amplification and processing overhead is reduced.
Patent Information
- Application Number
- CN202080048805.7
- Authority / Receiving Office
- CN · China
- Patent Type
- Patents(China)
- Current Assignee / Owner
- Priority Date
- 2019-07-01
- Filing Date
- 2020-06-23
- Publication Date
- 2024-11-08
- Estimated Expiration
- 2040-06-23
AI Technical Summary
The size adjustment of memory blocks in traditional SSDs is difficult to dynamically adapt to the performance requirements of the storage system, resulting in write amplification and data durability problems.
By dynamically adjusting the block pool size in the storage system, using a hybrid controller combined with SLC mode and MLC mode, reconfiguring the storage blocks based on actual use and workload properties to optimize storage performance and durability.
It realizes efficient performance and data durability of the storage system, reduces write amplification, dynamically adjusts the block pool size to avoid unnecessary processing overhead, and improves the overall performance and reliability of the system.
Smart Images

Figure CN114096952B_ABST
Abstract
Description
Technical Field
[0001] The present invention relates to a data storage system, and more particularly, to adjusting the size of a storage block pool in a storage system. Background Art
[0002] Taking flash memory as an example, the performance characteristics of traditional NAND flash-based solid-state drives (SSDs) are fundamentally different from those of traditional hard disk drives (HDDs). Data in traditional SSDs is usually organized in pages of 4, 8, or 16KB in size. In addition, page read operations in SSDs are usually an order of magnitude faster than write operations, and the latency depends neither on the current position of the operation nor on the previous position of the operation.
[0003] However, in flash-based SSDs, storage locations are erased in blocks before being written. The size of the erase block unit is from 256 to 512 or even thousands of pages, and the erase operation takes about an order of magnitude longer than the page programming operation. Due to the inherent properties of NAND flash memory, flash-based SSDs write data off-site, and a mapping table maps the logical address of the written data to the physical address. This mapping table is usually called a logical-to-physical table (LPT).
[0004] Because flash-based storage cells exhibit read errors and / or failures due to wear or other reasons, additional redundancy can be used within memory pages and across storage chips (e.g., RAID-5 and RAID-6 type schemes). Additional redundancy within a memory page can include error correction codes (ECC), which can, for example, include BCH, LDPC, or other codes. While adding ECC to a page is relatively simple, organizing storage blocks into RAID-like stripes is more complex. For example, individual blocks can be retired over time, which requires reorganizing the stripes or reducing the capacity of the stripes. Because the organization of the stripes, together with the LPT, defines the placement of data, SSDs typically utilize a log-structured array (LSA) architecture, which combines these two approaches.
[0005] The LSA architecture relies on out-of-place writes. In this approach, a memory page rewrite results in writing the memory page data to a new location in memory, marking the old copy of the memory page data as invalid, and then updating the mapping information. Due to limitations in current NAND memory technology, invalid data locations cannot be reused until the entire block to which they belong is erased. However, before being erased, the block is garbage collected, which relocates any valid data in the block to a new block. Garbage collection of a block is typically postponed for as long as possible to maximize the amount of invalid data in the block, thereby reducing the number of valid pages that are relocated, as relocating data results in additional write operations, which increases write amplification. Summary of the invention
[0006] According to an embodiment, a computer-implemented method is used to adjust the size of a block pool in a storage system. The computer-implemented method includes: determining whether the number of blocks included in a first ready-to-use (RTU) queue is within a first range of the first RTU queue. In response to determining that the number of blocks included in the first RTU queue is within the first range of the first RTU queue, determining whether the number of blocks included in the second RTU queue is within a second range of the second RTU queue. In addition, in response to determining that the number of blocks included in the second RTU queue is not within the second range of the second RTU queue, relocating valid data from one of the blocks in the first pool corresponding to the first RTU queue. The blocks in the first pool are erased and transferred from the first pool to a second RTU queue corresponding to the second pool. The blocks in the first pool are configured in a single-level cell (SLC) mode, and the blocks in the second pool are configured in a multi-bit per cell mode.
[0007] According to another embodiment, a computer program product includes a computer-readable storage medium having program instructions embodied therein. The program instructions can be read and / or executed by a processor to cause the processor to: perform the above method.
[0008] According to another embodiment, a system includes: a plurality of non-volatile random access memory (NVRAM) blocks configured to store data. The system also includes a processor and logic integrated with the processor and / or executable by the processor. The logic is configured to: perform the above method.
[0009] Other aspects and embodiments of the invention will become apparent from the following detailed description, which, when taken in conjunction with the accompanying drawings, illustrate by way of example the principles of the invention. BRIEF DESCRIPTION OF THE DRAWINGS
[0010] Figure 1 is a diagram of a nonvolatile memory card according to one embodiment.
[0011] Figure 2 is a diagram of a data storage system architecture according to one embodiment.
[0012] Figure 3 is a system diagram according to one embodiment.
[0013] Figure 4 is a conceptual diagram including block stripes and page stripes according to one embodiment.
[0014] Figure 5 is a schematic diagram of a non-volatile memory module according to one embodiment.
[0015] Fig. 6A is a flow chart of a method according to one embodiment.
[0016] Figure 6B is a flow chart of a method according to one embodiment.
[0017] Figure 6C For use according to one embodiment Fig. 6A and / or Figure 6B A flowchart of a sub-process of one of the operations in the method.
[0018] Figure 7 is a partial schematic diagram of a data and flow diagram overview according to one embodiment.
[0019] Figure 8 is a network architecture according to one embodiment.
[0020] Fig. 9 According to one embodiment, Figure 8 A representative hardware environment associated with a server and / or client.
[0021] Fig.10 is a hierarchical data storage system according to one embodiment. DETAILED DESCRIPTION
[0022] The following description is made to illustrate the general principles of the invention and is not intended to limit the inventive concepts claimed herein. Further, specific features described herein may be used in combination with other described features in each of the various possible combinations and permutations.
[0023] Unless otherwise specifically defined herein, all terms are to be given their broadest possible interpretations, including the meanings implied from the specification and as understood by those skilled in the art and / or as defined in dictionaries, treatises, and the like.
[0024] It must also be noted that, as used in the specification and the appended claims, the singular forms "a", "an", and "the" include plural referents unless otherwise specified. It should also be understood that when the terms "comprises" and / or "comprising" are used in this specification, they specify the presence of stated features, integers, steps, operations, elements, and / or components, but do not preclude the presence or addition of one or more other features, integers, steps, operations, elements, components, and / or combinations thereof.
[0025] The following description discloses several preferred embodiments of the data storage system and its operation and / or components. It should be understood that the different embodiments herein can be implemented with a wide range of storage media, including, for example, non-volatile random access memory (NVRAM) technology, such as NAND flash, NOR flash, phase change memory (PCM), magnetoresistive RAM (MRAM), and resistive RAM (RRAM). To provide context and only to assist the reader, different embodiments may be described with reference to types of non-volatile memory. This is done by way of example only and should not be considered a limitation of the invention defined in the claims.
[0026] In one general embodiment, a computer-implemented method is used to adjust the size of a block pool in a storage system. The computer-implemented method includes: determining whether the number of blocks included in a first ready-to-use (RTU) queue is within a first range of the first RTU queue. In response to determining that the number of blocks included in the first RTU queue is within the first range of the first RTU queue, determining whether the number of blocks included in the second RTU queue is within a second range of the second RTU queue. In addition, in response to determining that the number of blocks included in the second RTU queue is not within the second range of the second RTU queue, relocating valid data from one of the blocks in the first pool corresponding to the first RTU queue. The blocks in the first pool are erased and transferred from the first pool to a second RTU queue corresponding to the second pool. The blocks in the first pool are configured in a single-level cell (SLC) mode, and the blocks in the second pool are configured in a multi-bit per cell mode.
[0027] In another general embodiment, a computer program product includes a computer-readable storage medium having program instructions embodied therein. The program instructions can be read and / or executed by a processor to cause the processor to: perform the above method.
[0028] In yet another general embodiment, a system includes: a plurality of non-volatile random access memory (NVRAM) blocks configured to store data. The system also includes a processor and logic integrated with and / or executable by the processor. The logic is configured to: perform the above method.
[0029] Figure 1 A memory card 100 is shown according to one embodiment. It should be noted that although the memory card 100 is described in the present embodiment as an exemplary non-volatile data storage card, various other types of non-volatile data storage cards may be used in the data storage system according to alternative embodiments. Therefore, the architecture and / or components of the memory card 100 are in no way intended to limit the present invention, but are presented as non-limiting examples.
[0030] Additionally, the present memory card 100 may optionally be implemented in conjunction with features from any other embodiment listed herein, such as those described with reference to other figures. However, such memory card 100 and other memory cards presented herein may be used in a variety of applications and / or arrangements that may or may not be specifically described in the illustrative embodiments listed herein. Additionally, the memory card 100 presented herein may be used in any desired environment.
[0031] Continue to refer Figure 1 , the memory card 100 includes a gateway 102, a general purpose processor (GPP) 112 (such as ASIC, FPGA, CPU, etc.) connected to a GPP memory 114 (which may include RAM, ROM, battery-backed DRAM, phase change memory PC-RAM, MRAM, STT-MRAM, etc., or a combination thereof), and multiple memory controllers 108 (including flash controllers in this example). Each memory controller 108 is connected to multiple NVRAM memory modules 104 (which may include NAND flash or other non-volatile memory types, such as those listed above) via a channel 106.
[0032] According to various embodiments, the one or more controllers 108 may be or include one or more processors, and / or any logic for controlling any subsystem of the memory card 100. For example, the controller 108 generally controls the functions of the NVRAM memory module 104, such as data writing, data recycling, data reading, etc. In various embodiments, the controller 108 may operate using logic known in the art as well as any logic disclosed herein, and thus may be considered a processor for any description of non-volatile memory included herein.
[0033] In addition, the controller 108 may be configured and / or programmable to perform or control some or all of the methods presented herein. Therefore, the controller 108 may be considered to be configured to perform various operations through logic, software, firmware, and / or other instructions available to one or more processors programmed into one or more chips, modules, and / or blocks; and the like and combinations thereof.
[0034] Still reference Figure 1 Each memory controller 108 is also connected to a controller memory 110, which preferably includes a cache that replicates the non-volatile memory structure according to various embodiments described herein. However, depending on the desired embodiment, the controller memory 110 can be a battery-backed DRAM, phase-change memory PC-RAM, MRAM, STT-MRAM, etc., or a combination thereof.
[0035] As previously mentioned, memory card 100 may be implemented in different types of data storage systems depending on the desired embodiment. Figure 2 2 shows a data storage system architecture 200 according to an exemplary embodiment, which is in no way intended to limit the present invention. In addition, it should be noted that Figure 2 The data storage system 220 may include Figure 1 Various components found in an implementation of the invention.
[0036] See also Figure 2 , the data storage system 220 includes a plurality of interface cards 202 configured to communicate with one or more processor systems 201 via an I / O interconnect 204. The data storage system 220 may also include one or more RAID controllers 206 configured to control data storage in a plurality of non-volatile data storage cards 208. The non-volatile data storage cards 208 may include NVRAM, flash memory cards, RAM, ROM, and / or some other known type of non-volatile memory.
[0037] The I / O interconnect 204 may include any known communication protocol, such as Fibre Channel (FC), FC over Ethernet (FCoE), InfiniBand, Internet Small Computer System Interface (iSCSI), Transmission Control Protocol / Internet Protocol (TCP / IP), Peripheral Component Interconnect Express (PCIe), etc. and / or any combination thereof.
[0038] RAID controller 206 in data storage system 220 may implement a parity scheme similar to that employed by RAID-5, RAID-10, or some other suitable parity scheme, as will be understood by those skilled in the art upon reading this specification.
[0039] Each processor system 201 includes one or more processors 210 (such as a CPU, a microprocessor, etc.), a local data memory 211 (such as Fig. 9 RAM914, Fig. 9 ROM916, etc.), and an I / O adjuster 218 configured to communicate with a data storage system 220.
[0040] Reference again Figure 1 , memory controller 108, GPP 112, and / or other controllers described herein (e.g., Figure 2The RAID controller 206 of the storage system may be capable of performing various functions on the stored data depending on the desired implementation. Specifically, the storage controller or GPP 112 may include logic configured to perform any one or more of the following functions, which are by no means intended to be an exclusive list. In other words, as will be appreciated by those skilled in the art upon reading this specification, the logic of the storage system may be configured to perform additional or alternative functions depending on the desired embodiment.
[0041] Garbage Collection
[0042] Garbage collection in the context of an SSD memory controller of the present specification may include the process of identifying data blocks to be reclaimed for future use and relocating all pages therein that are still valid. In addition, depending on the specific controller and / or corresponding garbage collection unit of operation, logical erase blocks (LEBs) may be identified for reclaim and / or relocation. Typically, one LEB corresponds to one block stripe, but alternative implementations may also consider a fixed number of block stripes or a single block to construct an LEB.
[0043] A physical "block" represents the smallest unit that can be erased on a non-volatile memory (e.g., such as NAND flash memory) and thus prepared to write data to it. However, a typical garbage collection operation unit is often a multiple of a physical block of a non-volatile memory, and is also referred to herein as an LEB. This is because RAID-like parity information is usually added to the LEB. Therefore, in the event of a page or block failure, the data can only be rebuilt if all blocks in the LEB are still storing data. . Therefore, once all still valid data from all blocks in the LEB has been successfully relocated to a new location, the individual blocks from the garbage collection unit can only be erased individually or in a single unit. Therefore, all garbage collection units are garbage collected as a single unit. In addition, the size of the LEB directly affects the write amplification caused by garbage collection. The larger the LEB, the greater the possibility that unrelated data is stored together in the LEB, so more LEB data may need to be relocated when garbage collection is selected.
[0044] Typically, blocks from different dies and / or flash channels are grouped together so that blocks from the same group can be read or written in parallel, thereby increasing the overall bandwidth. It is also possible to combine the previous two approaches and use blocks from different flash channels that can be accessed in parallel to form a RAID stripe.
[0045] It should also be noted that an LEB can include any multiple of a physical storage block, which is a unit of physical erasure. In addition, organizing storage blocks into LEBs not only allows for the addition of RAID-like parity protection schemes between storage blocks from different memory chips, memory planes, and / or channels, but also allows for significantly enhanced performance through higher parallelism. For example, multiple non-volatile storage blocks can be combined together in a RAID stripe. Those skilled in the art will understand after reading this specification that RAID schemes generally improve reliability and reduce the probability of data loss.
[0046] According to an exemplary embodiment which is in no way intended to limit the present invention, a memory controller (e.g., see Figure 1 108) and / or GPP112 can perform garbage collection internally. As previously described, garbage collection can include selecting an LEB to be relocated, after which all data that is still valid on the selected LEB can be relocated (e.g., moved). After relocating the still valid data, the LEB can be erased and then used to store new data. Write amplification is determined from the amount of data relocated from the garbage collected LEB. In addition, an effective method of reducing write amplification includes implementing write hot separation.
[0047] Write hot separation
[0048] In this context, the "write heat" of data refers to the rate (e.g., frequency) at which the data is updated (e.g., overwritten with new data). Storage blocks that are considered "hot" tend to have frequent update rates, while storage blocks that are considered "cold" have slower update rates than hot blocks.
[0049] Tracking the write heat of a logical page may involve, for example, allocating a specific number of bits in an LPT mapping entry for the page to track how many write operations the page has seen in a certain time period or window. Typically, host write operations increase write heat, while internal relocation writes decrease write heat. The actual increment and / or decrease in write heat may be deterministic or probabilistic.
[0050] Similarly, for each logical page, a specific number of additional bits in the LPT can be used to track read heat. In order to reduce metadata, read heat can also be tracked at the physical block level, where a separate counter for each block for straddling and non-straddling reads can be maintained. However, it should be noted that for some embodiments, when determining the write heat of a storage block, the number of read requests to the storage block and / or read operations performed on the storage block may not work for write heat separation. For example, if data is frequently read from a specific storage block, a high read frequency does not necessarily mean that the storage block will also have a high update rate. On the contrary, a high frequency of read operations performed on a given storage block may represent the importance, value, etc. of the data stored in the storage block.
[0051] Write heat separation can be achieved by grouping storage blocks with the same and / or similar write heat values. Specifically, the heat isolation method can group hot memory pages together in certain storage blocks, while grouping cold memory pages together in separate storage blocks. Therefore, the heat isolation LEBs tend to be occupied by hot or cold data.
[0052] The advantage of write hot separation is twofold. First, performing garbage collection on hot storage blocks will also prevent triggering relocation of cold data. Without write hot separation, frequently performed hot data updates will also cause undesired relocation of all cold data collocated on the same LEB as the relocated hot data. Therefore, for embodiments implementing write hot separation, the write amplification caused by performing garbage collection is much lower.
[0053] Second, the relative heat of the data can be used for wear leveling purposes. For example, hot data can be placed in healthier (e.g., younger) storage blocks, while cold data can be placed on less healthy (e.g., older) storage blocks relative to those healthier storage blocks. Thus, the rate at which relatively older blocks are exposed to wear is effectively slowed, thereby improving the overall durability of a given data storage system that implements write-hot separation.
[0054] Write Allocation
[0055] Write allocation involves placing the data of a write operation into a free location in an open LEB. Once all pages in a LEB are written, the LEB is closed and placed in a pool of occupied LEBs. Typically, LEBs in an occupied pool are eligible for garbage collection. The number of open LEBs is usually limited, and any closed LEB can be replaced immediately or after some delay with a new LEB that is opened by associating one or more erase blocks to the LEB.
[0056] During execution, garbage collection can occur concurrently with user write operations. For example, while a user (e.g., a host) is writing data to a device, the device controller can continuously perform garbage collection on LEBs of invalid data to make room for new incoming data pages. As described above, the LEBs on which garbage collection is performed will typically have some pages that are still valid at the time of the garbage collection operation; therefore, these pages are preferably relocated (e.g., written) to new LEBs.
[0057] Again, the aforementioned functions are in no way intended to limit the capabilities of any storage system described and / or suggested herein. Rather, as will be appreciated by those skilled in the art upon reading this specification, the aforementioned functions are presented by way of example, and depending on the desired embodiment, the logic of the storage system may be configured to perform additional or alternative functions.
[0058] Reference now Figure 3 , a system 300 according to one embodiment is shown. Alternatively, the present system 300 may be implemented in conjunction with features from any other implementations listed herein, such as those described with reference to other figures. However, this system 300 and other systems presented herein may be used in different applications and / or combinations, which may or may not be specifically described in the illustrative embodiments listed herein. Furthermore, the system 300 presented herein may be used in any desired environment, for example, in conjunction with a controller.
[0059] As shown, system 300 includes a write cache 302 coupled to several other components, including a garbage collector 304. As previously described, garbage collector 304 can be used to free up LEB units by relocating valid data and providing non-volatile storage blocks to be erased for later reuse. Thus, depending on the desired embodiment, garbage collector 304 can reclaim blocks of contiguous physical space. According to an exemplary embodiment, a block erase unit can be used to track and / or complete the erasure of non-volatile storage blocks handed over by garbage collector 304.
[0060] The write cache 302 is also coupled to a free block manager 306, which can track free non-volatile memory blocks after they have been erased. In addition, as will be appreciated by one of ordinary skill in the art after reading this specification, the free block manager 306 can use the erased free non-volatile memory blocks to build free stripes (e.g., block stripes) of non-volatile memory blocks from different channels.
[0061] Still refer to Figure 3 , the write cache 302 is coupled to an LPT manager 308 and a memory I / O unit 310. The LPT manager 308 maintains a logical-to-physical mapping of logical addresses to physical pages in memory. According to an example that is in no way intended to limit the present invention, the LPT manager 308 may maintain a logical-to-physical mapping of 4KiB or 16KiB logical addresses. The memory I / O unit 310 communicates with the memory chip to perform low-level operations, such as reading one or more non-volatile memory pages, writing non-volatile memory pages, erasing non-volatile memory blocks, etc.
[0062] To better understand the difference between block stripes and page stripes as used in this article, Figure 4is a conceptual diagram 400 according to one embodiment. The LEB is constructed from block strips, and typically a single block strip is used to construct the LEB. However, alternative embodiments may use multiple block strips to form the LEB. As an option, this conceptual diagram 400 may be implemented in conjunction with features from any other implementation listed herein, such as those described with reference to other figures. However, this conceptual diagram 400 and other conceptual diagrams presented herein may be used in different applications and / or arrangements that may or may not be specifically described in the illustrative embodiments listed herein. Further, the controller conceptual diagram 400 presented herein may be used in any desired environment. Therefore, Figure 4 The exemplary non-volatile memory controller conceptual diagram 400 may be implemented in a cache architecture. However, depending on the desired implementation, other methods may be implemented when defining the organization of data stored in the non-volatile memory. Figure 4 Therefore, the two implementations are described in turn below.
[0063] Non-volatile memory
[0064] See now Figure 4 , conceptual diagram 400 includes a set of M+1 aggregated planes labeled “Plane 0” to “Plane M”. An aggregated plane consists of all physical planes with the same plane index on different channels. It should be noted that aggregated planes are also referred to herein as simply planes.
[0065] When implemented with data stored in non-volatile memory, each physical plane on a channel may include a large set of blocks, e.g., typically 1024, 2048, or more. In addition, one or more physical planes may also include a number of additional blocks that may be used as replacement blocks for bad blocks (e.g., blocks with poor performance, blocks with undesirable characteristics, etc.).
[0066] In each plane of the non-volatile memory, a single block from each channel may form a corresponding block stripe. Thus, the number of block stripes supported by a given embodiment of the non-volatile memory may be determined by the number of blocks per plane and the number of planes.
[0067] In the exploded view of plane 0, conceptual diagram 400 further illustrates a single block stripe (block stripe 0) among a set of block stripes supported by the rest of the plane. Block stripe 0 of plane 0 is shown to include 11 blocks, one block for each channel labeled "channel 0" to "channel 10". It should be noted that the association of blocks with block stripes can change over time because block stripes are typically dissolved after they are garbage collected. Erased blocks can be placed in a free block pool, whereby when a write allocation requests a new block stripe, the new block stripe is assembled from blocks in the free block pool. For example, looking at conceptual diagram 400, block 10 from channel 0 and block 41 from channel 4 are currently associated with block stripe 0 of plane 0 shown. In addition, the block stripe 0 shown maintains N+1 page stripes, and each block therefore maintains N+1 pages labeled "page 0" to "page N".
[0068] Cache Architecture
[0069] Still refer to Figure 4 , when implemented in a cache architecture, each block of pages shown in the exploded view of aggregation plane 0 may constitute a unique block of a channel. Similarly, each channel contributes a single block, forming a block stripe. For example, looking at conceptual diagram 400, block 10 from channel 0 includes all pages therein (page 0 to page N), while block 41 from channel 4 corresponds to all pages therein, and so on.
[0070] In the context of a memory controller, for example, it might be able to implement RAID at the channel level, with a block stripe consisting of multiple blocks that act as a block stripe. Figure 4 , multiple blocks of aggregation plane 0 constitute block stripe 0. Although all blocks in a block stripe usually belong to the same aggregation plane, in some embodiments, one or more blocks of a block stripe may belong to different physical planes. It follows that each aggregation plane may include one or more block stripes. Therefore, according to an illustrative embodiment, blocks 0 to 10 from different physical planes may constitute a block stripe.
[0071] in spite of Figure 4 Whether the conceptual diagram 400 is implemented using non-volatile memory and / or a cache architecture, in different embodiments, the number of pages in each block and / or the number of channels in each plane may vary depending on the desired embodiment. According to an exemplary embodiment that is not intended to limit the present invention in any way, a block may include 256 pages, but may include more or fewer pages in different embodiments. Similarly, the number of channels per plane and / or the number of planes may vary depending on the desired embodiment.
[0072] Still refer to Figure 4, all pages in a block stripe with the same page index represent a page stripe. For example, page stripe 0 includes the first page (page 0) of each channel in block stripe 0 of plane 0. Similarly, page stripe N includes the last page (page N) of each channel in block stripe 0 of plane 0.
[0073] As mentioned above, the physical configuration of the storage blocks in non-volatile memory changes over time. For example, in the past, flash memory blocks had a configuration of one bit per cell, but improvements in data storage have introduced flash memory blocks that implement multi-bit configurations per cell. Although blocks with multi-bit configurations per cell can store more information than blocks with one bit configuration per cell, this increase in storage capacity is at the expense of performance delay. For example, a storage block with a configuration of one bit per cell experiences a write delay that is about 2.5 times to about 10 times lower than the write delay experienced by a storage block with multi-bit configuration per cell. Similarly, a storage block with a configuration of one bit per cell experiences a lower read delay than a storage block with a configuration of one bit per cell.
[0074] This tradeoff between storage capacity and performance latency allows storage systems to customize the performance capabilities of storage to some extent. For example, a storage system that is predicted to have a large amount of I / O traffic can selectively include a larger number of storage blocks with a one-bit per cell configuration than storage blocks with a multi-bit per cell configuration. Conversely, a storage system that is predicted to store a large amount of cold data can selectively include a larger number of storage blocks with a multi-bit per cell configuration than storage blocks with a one-bit per cell configuration. However, real-time usage will often differ from the predictions that may have been considered when designing these storage systems. Therefore, traditional storage systems have been unable to maintain efficient performance.
[0075] In stark contrast to the aforementioned shortcomings experienced by conventional systems, the embodiments included herein implement a hybrid controller that is capable of dynamically adjusting block pool sizes based on current utilization and workload attributes, for example, as will be described in further detail below.
[0076] See now Figure 5 , shows a non-volatile memory module 500 with a hybrid controller 502 according to one embodiment. Alternatively, the present memory module 500 may be implemented in conjunction with features from any other implementation listed herein, such as those described with reference to other figures. However, such a memory module 500 and others presented herein may be used in a variety of applications and / or arrangements that may or may not be specifically described in the illustrative embodiments listed herein. Further, the memory module 500 presented herein may be used in any desired environment. Therefore, Figure 5 (and other figures) may be considered to include any possible permutations.
[0077] As described above, the memory module 500 includes a hybrid controller 502 that is capable of managing and / or adjusting blocks configured in a one-bit per cell mode (also referred to herein as a "single-level cell mode" or "SLC mode") as well as a multi-bit per cell mode. According to some approaches, the hybrid controller 502 manages the different block configurations by splitting them into two different pools 504, 506. One of these pools 504 is designated to include those blocks configured in the SLC mode, while the other pool 506 includes blocks configured in the multi-bit per cell mode.
[0078] Each of the pools 504, 506 spans multiple data storage components (e.g., NVRAM memory modules such as NAND flash memory devices), which together function as a memory array 508. Thus, Figure 5 The various components shown in FIG. 1 are used as a memory card, and the above-mentioned Figure 1 The memory card 100 may be used in any of the methods described herein.
[0079] Still refer to Figure 5 , the hybrid controller 502 is also coupled to a cache memory 510 and a gateway 512 that receives data commands from one or more hosts, storage systems, running applications, etc. The gateway 512 is in turn coupled to the GPP 514 and the 3GPP memory 516. As described above, the GPP 514 can be of any desired type, such as an ASIC, FPGA, CPU, etc. Similarly, the GPP memory 516 can be of any desired type, such as RAM, ROM, battery-backed DRAM, phase change memory PC-RAM, MRAM, STT-MRAM, etc., and / or combinations thereof.
[0080] Thus, the hybrid controller is able to store data that is frequently accessed (e.g., read, rewritten, appended to, etc.) in blocks configured in SLC mode and therefore included in the first pool 504, while data that is accessed less frequently is stored in blocks configured in multi-bit per cell mode and therefore included in blocks in the second pool 506. Since the hybrid controller can be used to first write user writes to blocks that are first configured in SLC mode, and only data that is still valid is later downgraded to multi-bit per cell blocks in the background, the number of write operations performed on blocks in the second pool is significantly reduced, so that the overall endurance is increased. This storage scheme enables efficient use of different storage blocks of the memory and their corresponding performance characteristics. However, as the ratio of hot data and cold data stored in the memory module 500 fluctuates over time, each of the corresponding pools 504, 506 may be underutilized and / or overutilized.
[0081] Thus, the hybrid controller 502 is able to selectively reconfigure any block in the first and / or second pools 504, 506 to dynamically adjust based on actual usage and / or workload attributes. This allows the memory module 500 to maintain efficient performance regardless of the amount of hot or cold data stored therein. Fig. 6A , shows a method 600 for adjusting the block pool size in a storage system according to one embodiment. In various embodiments, among other environments, the method 600 may be implemented according to the present invention. Figure 1-5 Of course, as will be understood by those skilled in the art after reading this specification, method 600 may include more Fig. 6A For example, the various processes included in method 600 are described below in the context of converting a memory block configured in SLC mode to a memory block configured in multi-bit per cell mode. However, any one or more of the different processes included in method 600 may be applied in the context of converting a memory block configured in multi-bit per cell mode to a memory block configured in SLC mode (e.g., see below). Figure 6B ).
[0082] Each step of method 600 may be performed by any suitable component of the operating environment. For example, in different embodiments, method 600 may be performed in part or in full by a hybrid controller, a controller, a processor, a computer, etc., or some other device having one or more processors therein. Therefore, in some embodiments, method 600 may be a computer-implemented method. In such an embodiment, a computer for implementing the method may include the memory module itself or a portion thereof, such as a hybrid controller. In addition, the terms "computer", "processor" and "controller" may be used interchangeably with respect to any embodiment of the present invention, and such components are considered equivalent in many different arrangements of the present invention.
[0083] Furthermore, for those embodiments having a processor, a processor (e.g., a processing circuit, chip, and / or module implemented in hardware and / or software), and preferably having at least one hardware component, may be used in any device to perform one or more steps of method 600. Illustrative processors include, but are not limited to, a central processing unit (CPU), an application specific integrated circuit (ASIC), a field programmable gate array (FPGA), etc., combinations thereof, or any other suitable computing device known in the art.
[0084] like Fig. 6AAs shown, operation 602 of method 600 includes evaluating the size of a first ready-to-use (RTU) queue and the size of a second RTU queue. Each of the first and second RTU queues includes storage blocks merged in first and second storage block pools, respectively. In addition, each of the first and second pools includes storage blocks configured in different modes. As described above, the first pool includes storage blocks configured in SLC mode, and the second pool includes storage blocks configured in multi-bit per cell mode. Therefore, the first RTU queue includes storage blocks configured in SLC mode, and the second RTU queue includes storage blocks configured in multi-bit mode. According to the method, the blocks configured in multi-bit per cell mode in the second pool may have multiple different configurations. For example, in some methods, the blocks configured in multi-bit per cell mode in the second pool are configured in multi-level cell (MLC) mode, while in other methods, the blocks configured in multi-bit per cell mode in the second pool are configured in triple-level cell (TLC) mode. In still other methods, the blocks configured in the multi-bit-per-cell mode in the second pool are configured in a quad-level cell (QLC) mode, and each of the blocks configured in the QLC mode includes a lower page, an upper page, an additional page, and a top page.
[0085] With respect to the present description, the "size" of a given RTU queue is intended to mean the amount of erased storage blocks included therein. Initially, when no data is written to the device, the size of the RTU queue represents the total storage capacity because all blocks are erased and placed in the RTU queue according to their pattern. Over time, as data is written to the non-volatile memory module, new LEBs are opened for data placement by taking blocks from the corresponding RTU, thereby reducing their size. At some point, the opening and closing of LEBs results in a low queue level in any RTU, at which point garbage collection must be performed. The size of an RTU can be expressed as (e.g., quantified use of) the number of blocks included in the RTU queue, the combined storage capacity of the blocks included in the RTU queue, the percentage of the total number of blocks included in the overall system included in the RTU queue, etc. According to some methods, the size of the first and / or second RTU queues is evaluated by actually inspecting the queues themselves, retrieving information from counters, lookup tables, viewing operation logs, etc.
[0086] In addition, decision 604 includes determining whether the number of blocks included in the first RTU queue is within a first range of the first RTU queue. Therefore, in a preferred embodiment, the first range is dedicated to the first RTU queue. However, in some methods, the first range can be the same or similar for the first RTU queue and the second RTU queue. The first RTU queue also preferably corresponds to a garbage collection threshold for the first RTU queue, so that a garbage collection operation is performed in response to determining that the number of blocks included in the first RTU queue is too low. The garbage collection process will relocate valid data from one or more blocks in the first pool so that one or more blocks can be placed in the first RTU queue, thereby increasing the number of blocks included therein, for example, as will become apparent shortly. However, it should be noted that "within a first range" is by no means intended to limit the present invention. Instead of determining whether a value is within a given range, an equivalent determination can be made, for example, as to whether a value is above a predetermined threshold, whether a value is outside a predetermined range, whether an absolute value is above a threshold, whether a value is below a threshold, etc., depending on the desired method.
[0087] As previously described, the method 600 proceeds to operation 606 in response to determining that the number of blocks included in the first RTU queue is not within the first range of the first RTU queue. There, operation 606 includes selecting one of the blocks in the first pool, and operation 608 includes relocating all valid data from the selected block. The block selected in operation 606 will undergo the garbage collection process initiated in operation 608. Thus, in some methods, the block with the most invalid data among all the blocks in the first pool is selected. However, any other desired factors can be considered in the process of selecting a block in the first pool for the garbage collection process. For example, when selecting the blocks in the first pool, the age of each block, the amount of valid data included in each block, etc. can be considered.
[0088] Relocating the valid data from the selected block may further be performed in any desired manner. For example, in some approaches, the valid data may be temporarily stored in a cache before being stored in a different block of memory (e.g., see Figure 5 In other methods, the valid data can be directly transferred to another storage block. In response to relocating the valid data from the selected block, operation 610 includes erasing the selected block.
[0089] Continuing to operation 612, the method 600 includes placing the selected (now erased) blocks in a first RTU queue corresponding to the first pool. As described above, each of the first and second RTU queues includes storage blocks incorporated into the first and second storage block pools, respectively. Thus, by performing garbage collection operations on the selected blocks and placing them in the first RTU queue, the selected blocks are effectively used to help fill the first RTU queue. This ideally avoids latency issues by ensuring that a predetermined number of available (e.g., empty) blocks are included in the first RTU queue.
[0090] It should also be noted that in some methods, when data is stored in a page and the block has not yet been erased, the block undergoes a read threshold voltage offset value recalibration. Therefore, in some methods, the process of placing the selected (and now erased) block in the first RTU queue involves marking the block for recalibrating the read threshold voltage offset value. After reading this specification, any process that is obvious to those skilled in the art can be used to recalibrate the read threshold voltage offset value. For example, calibrating the read threshold voltage offset value can be performed when the pages in the block are actually programmed. Therefore, after the block has been erased, it may not actually be possible to directly recalibrate the read threshold voltage offset value. Instead, an erased block that has been marked for read threshold voltage offset value calibration will wait until the block is reprogrammed again to perform calibration.
[0091] Still refer to Fig. 6A , the method 600 returns from operation 612 to operation 602, for example, so that the size of the first and / or second RTU queues can continue to be monitored. Jumping back to decision 604, in response to determining that the number of blocks included in the first RTU queue is within a first range for the first RTU queue, the flowchart proceeds to decision 614. In other words, in response to determining that the first RTU queue includes a desired number of storage blocks therein, the method 600 proceeds from decision 604 to decision 614. Again, the first range corresponds to the first RTU queue and can be predetermined by a user based on industry standards, based on system performance adjustments, etc.
[0092] Decision 614 includes determining whether the size of the first pool should be reduced. In other words, decision 614 determines that the number of storage blocks included in the first pool is undesirably or at least unnecessarily high. The determination can be made by comparing the target size of the first pool with the current (e.g., actual) size of the first pool. The number of storage blocks in the first pool includes all blocks in a corresponding mode associated with the first pool, regardless of whether the block is in an open or closed LEB, or in a first RTU. The target size of the first pool can be predetermined by a user, specified based on a predicted workload of the overall architecture system, etc.
[0093] In response to determining that the size of the first pool should not be reduced, the method 600 returns to operation 602, for example, so that the size of the first and / or second RTU queues can continue to be monitored. However, in response to determining that the size of the first pool should be reduced, the method 600 proceeds from decision 614 to decision 616. Here, decision 616 includes determining whether the number of blocks included in the second RTU queue is within a second range of the second RTU queue. Therefore, the second range is preferably specific to the second RTU queue. However, it should also be noted that in some methods, the second range can be the same or similar for the first RTU queue and the second RTU queue. This second range of the second RTU queue can also correspond to the "lifting threshold" in the preferred method, thereby evaluating the RTU queue of the target location when determining whether to transfer a block from one pool to another pool. This can ensure that the target location does not overflow by preventing block conversions between pools even before the target pool has reached its capacity. In other words, even if the first RTU queue and the first pool (e.g., the "source location") are fully filled with storage blocks, the state of the second RTU queue (e.g., the "target location") is taken into account before deciding to unload storage blocks from the first pool. In addition, the boost threshold can be dynamically adjusted during real time based on the current amount of block transfers involved in the current workload attributes. In a preferred embodiment, the boost threshold is higher than the threshold that stops garbage collection in the same pool. For some methods involving resizing a pool of blocks, the boost threshold of the target (e.g., "receiving") pool can be reduced in proportion to the number of blocks expected to be added. This reduction can be performed when the boost threshold of the source pool is increased, or after blocks have been extracted from the source pool.
[0094] Evaluating the source location as well as the target location is particularly desirable because it avoids unnecessary processing overhead. Specifically, resizing the block pool can affect the I / O latency and throughput of the entire system. This is at least in part because block transfers can exhaust blocks in one of the RTU queues, thereby potentially causing processing delays. Even if the RTU queue is not exhausted, block transfers can reduce the free block count in a given pool to below the desired level, causing garbage collection operations to be performed more aggressively. The overhead generated by the additional garbage collection operations can result in undesirable throttling of host operations. In addition, changing the configuration or "mode" of a given block incurs overhead. For example, when switching between block configuration modes, additional controller metadata is updated. In addition, the process of relocating valid data from the block being reconfigured and / or recalibrating the threshold voltage offset value of the block introduces additional processing overhead.
[0095] Thus, by evaluating the source location and the target location before performing a storage block transfer between the source location and the target location, the system is able to limit such transfers, thereby desirably avoiding unnecessary processing overhead. It should also be noted that "within a second range" is in no way intended to limit the present invention. As described above, rather than determining whether a value is within a given range, an equivalent determination can be made, for example, as to whether a value is above a predetermined threshold (e.g., a raised threshold), whether a value is outside a predetermined range, whether an absolute value is above a threshold, whether a value is below a threshold, etc., depending on the desired approach.
[0096] Pool resizing can be further enabled intelligently by limiting the speed of resizing to the speed at which blocks are consumed in the target pool. In other words, since the evaluation of the source and target locations facilitates deferring garbage collection of blocks, even if the pool must be resized, the total overhead is further minimized, thereby maximizing the amount of invalid data in blocks selected for garbage collection during resizing, reducing the number of valid pages to be relocated, and effectively reducing write amplification.
[0097] Still refer to Fig. 6A , the method 600 returns from decision 616 to operation 602 in response to determining that the number of blocks included in the second RTU queue is within the second range of the second RTU queue. As described above, this allows the method 600 to continue monitoring the size of the first and / or second RTU queues. The method 600 may alternatively proceed to decision 618 in response to determining that the number of blocks included in the second RTU queue is not within the second range of the second RTU queue.
[0098] Continuing to decision 618, method 600 includes determining whether the current input / output (I / O) workload experienced by the storage system is within a third range. As implied above, the process of transferring storage blocks between pools is a workload-intensive process, which may have an impact on the performance of the overall system. Therefore, by evaluating the current I / O workload of the storage system when determining whether and / or when to transfer storage blocks between pools, method 600 is able to target low I / O workloads and reduce the resulting processing impact. Again, "within a third range" is in no way intended to limit the present invention. As described above, rather than determining whether a value is within a given range, an equivalent determination can be made, for example, whether a value is above a predetermined threshold, whether a value is outside a predetermined range, whether an absolute value is above a threshold, whether a value is below a threshold, etc., depending on the desired method. It should also be noted that the result of decision 618 can be determined deterministically or probabilistically. Therefore, determining whether a value is within a given range can also include whether a value has a certain probability within a given range, and the decision made can be based on the probability.
[0099] Method 600 returns to operation 602 in response to determining that the current I / O workload experienced by the storage system is in the third range. In other words, method 600 enters operation 620 in response to determining that the current I / O workload of the storage system is undesirably high. However, method 600 advances to operation 620 in response to determining that the current I / O workload experienced by the storage system is not in the third range. There, operation 620 includes selecting one of the blocks in the first pool. The block selected in operation 620 will undergo garbage collection processing. Thus, in some methods, the block with the most invalid data among all blocks in the first pool is selected. However, any other desired factors can be considered in the process of selecting one of the blocks in the first pool for garbage collection processing. For example, when selecting on the blocks in the first pool, the age of each block, the amount of valid data included in each block, whether a given block is eligible to be transmitted, etc. can be considered.
[0100] Operation 622 also includes relocating valid data from the selected block in the first pool. Depending on the method, the relocation of valid data from the selected block can be performed in any desired manner. For example, in some methods, the valid data can be temporarily stored in a cache before being stored in a different block of memory (e.g., see Figure 5 In other methods, the valid data can be directly transferred to another block of memory. In response to relocating the valid data from the selected block, operation 624 includes erasing the selected block.
[0101] In addition, operation 626 includes transferring the block from the first pool to a second RTU queue corresponding to the second pool. According to the present description, blocks that are "transferred" between RTU queues and / or pools remain in the same plane and channel of memory (e.g., see Figure 4 ). In other words, while the functional characteristics of a given block may change as a result of activating and / or deactivating certain bits in each cell therein, the block itself is not physically moved in memory. Rather, in a logical sense, blocks are "transferred" between RTU queues and / or pools. In some approaches, these transfers are indicated in an LPT, a block status table, an operation log, etc.
[0102] Again, the first pool (along with the first RTU queue) includes memory blocks configured in SLC mode, while the second pool (along with the second RTU queue) includes memory blocks configured in multi-bit per cell mode. Therefore, since each of the first and second pools includes memory blocks configured in different modes, the process of actually transferring the selected blocks in operation 626 includes reconfiguring the blocks. Figure 6C , shows an exemplary sub-process for transferring a given block between a first pool and a second RTU queue according to one embodiment, one or more of which may be used to perform the following Fig. 6A Operation 626 and / or Figure 6B operation 656. However, it should be noted that Figure 6C The sub-processes of are shown according to one embodiment, which is in no way intended to limit the present invention.
[0103] As shown in the figure, Figure 6C The flowchart in includes reconfiguring the selected block. See sub-operation 670. Depending on whether the selected block is transferred from the first pool to the second RTU queue or from the second pool to the first RTU queue, the process of reconfiguring the storage block can be performed differently. For example, the block transferred from the first pool to the second RTU queue is preferably reconfigured from the SLC mode to the multi-bit per unit mode. However, the block transferred from the second pool to the first RTU queue is preferably reconfigured from the multi-bit per unit mode to the SLC mode. The process of reconfiguring a given block between the SLC and multi-bit per unit modes can be performed by deactivating and / or reactivating certain bits included in the block, logically redefining the given block, etc., or using any process that will be obvious to a person skilled in the art after reading this description.
[0104] Recalibrating the block can affect the performance of the block. For example, the read threshold voltage offset value associated with accessing a given block in the second pool may change due to the block being used in the first pool. Therefore, the flowchart also includes marking the block to recalibrate the read threshold voltage offset value in the target mode once the block is programmed again. See sub-operation 672. After reading this specification, any process obvious to those skilled in the art can be used to recalibrate the read threshold voltage offset value. However, in some methods, the read threshold voltage offset value, predefined read threshold voltage offset value, dynamically adjusted read threshold voltage offset value, etc. can be accessed from a memory (e.g., a lookup table). In addition, sub-operation 672 includes recalibrating one or more read threshold voltage offset values for each valid bit in a given block in some methods.
[0105] Return to reference Fig. 6A , method 600 returns from operation 626 to operation 602, for example, so that the size of the first and / or second RTU queues can continue to be monitored. Therefore, method 600 can successfully adjust the block pool size in real time while maintaining efficient performance of the overall storage system.
[0106] As previously described, one or more of the various processes included in method 600 may be applied in the context of converting a memory block configured in a multi-bit per cell mode to a memory block configured in an SLC mode. Figure 6B , shows a method 630 for adjusting the block pool size in a storage system according to another embodiment. In various implementations, the method 630 may be implemented in the present invention. Figure 1-6AOf course, as will be understood by those skilled in the art after reading this specification, method 630 may include more Figure 6B For example, the different processes included in method 630 are described below in the context of transitioning a memory block configured in a multi-bit per cell mode to a memory block configured in an SLC mode. Fig. 6A Any one or more of the methods described in method 600 may be implemented in method 630 as needed.
[0107] Each of the steps of method 630 may also be performed by any suitable component of the operating environment. For example, in different embodiments, method 630 may be performed in part or in full by a hybrid controller, a controller, a processor, a computer, etc., or some other device having one or more processors therein. Therefore, in some embodiments, method 630 may be a computer-implemented method. In such an embodiment, a computer for implementing the method may include the memory module itself or a portion thereof, such as a hybrid controller. In addition, the terms "computer", "processor" and "controller" may be used interchangeably with respect to any embodiment herein, and such components are considered equivalent in many different arrangements of the present invention.
[0108] Furthermore, for those embodiments having a processor, a processor (e.g., a processing circuit, chip, and / or module implemented in hardware and / or software) and preferably having at least one hardware component may be used in any device to perform one or more steps of method 630. Illustrative processors include, but are not limited to, a central processing unit (CPU), an application specific integrated circuit (ASIC), a field programmable gate array (FPGA), etc., combinations thereof, or any other suitable computing device known in the art.
[0109] like Figure 6B As shown, operation 632 of method 630 includes evaluating the size of a first ready-to-use (RTU) queue and the size of a second RTU queue. Each of the first and second RTU queues includes memory blocks merged in first and second memory block pools, respectively. In addition, each of the first and second pools includes memory blocks configured in different modes. As described above, the first pool includes memory blocks configured in SLC mode, and the second pool includes memory blocks configured in multi-bit per cell mode. Therefore, the first RTU queue includes memory blocks configured in SLC mode, and the second RTU queue includes memory blocks configured in multi-bit / cell mode.
[0110] Again, with respect to the present description, the "size" of a given RTU queue is intended to refer to the amount of erased storage blocks included therein. The size of an RTU queue thus refers to the total storage capacity of a given RTU queue, and may be represented (e.g., quantified) by the number of blocks included in the RTU queue, the combined storage capacity of the blocks included in the RTU queue, the percentage of the total number of blocks included in the total system included in the RTU queue, etc. According to some approaches, the size of the first and / or second RTU queues is assessed by actually inspecting the queues themselves, retrieving information from a lookup table, viewing an operation log, etc.
[0111] In addition, decision 634 includes determining whether the number of blocks included in the second RTU queue is within a first range of the second RTU queue. As described above, in a preferred method, the first range corresponds to a garbage collection threshold, such that a garbage collection operation is performed in response to determining that the number of blocks included in the second RTU queue is undesirably low. Note that the first range is associated with the second RTU and may be the same or different than the first range associated with the first RTU introduced in method 600, for example, as will be understood by those skilled in the art after reading this specification.
[0112] In response to determining that the number of blocks included in the second RTU queue is not in the first range of the second RTU queue, the method 600 proceeds to operation 636. There, operation 636 includes selecting one of the blocks in the second pool, and operation 638 includes relocating all valid data from the selected block. The block selected in operation 636 will undergo the garbage collection process initiated in operation 638. Thus, in some methods, the block with the most invalid data among all the blocks in the second pool is selected. However, any other desired factors can be considered in the process of selecting one of the blocks in the second pool to undergo the garbage collection process.
[0113] In response to relocating valid data from the selected block, operation 640 includes erasing the selected block. Continuing to operation 642, method 630 includes placing the selected (and now erased) block in a second RTU queue corresponding to the second pool. It should also be noted that in some methods, when data is stored in the page and the block has not been erased, the block undergoes read threshold voltage offset value recalibration. Therefore, in some methods, the process of placing the selected (and now erased) block in the second RTU queue involves marking the block for recalibration of the read threshold voltage offset value, for example, using any process that is obvious to a person skilled in the art after reading this specification.
[0114] Still refer to Figure 6B, the method 630 returns from operation 642 to operation 632, for example, so that the size of the first and / or second RTU queues can continue to be monitored. Jumping back to decision 634, in response to determining that the number of blocks included in the second RTU queue is within the first range of the second RTU queue, the flowchart proceeds to decision 644. There, decision 644 includes determining whether the size of the second pool should be reduced. In other words, decision 644 determines whether the number of storage blocks included in the second pool is undesirable, or at least unnecessarily high. This determination can be made by comparing the target size of the second pool with the current (e.g., actual) size of the second pool.
[0115] In response to determining that the size of the second pool should not be reduced, the method 630 returns to operation 632, for example, so that the size of the first and / or second RTU queues can continue to be monitored. However, the method 630 proceeds from decision 644 to decision 646 in response to determining that the size of the second pool should be reduced. Here, decision 646 includes determining whether the number of blocks included in the first RTU queue is within a second range of the first RTU queue. This second range of the first RTU queue is associated with the first RTU queue itself and corresponds to a "promotion threshold" in a preferred manner, so that the RTU queue at the target location is evaluated when determining whether to transfer blocks from one pool to another pool. In other words, even if the second RTU queue and the second pool (e.g., "source location") storage blocks are fully filled, the state of the first RTU queue (e.g., "target location") is also considered before deciding to unload storage blocks from the second pool, which is particularly desirable for the reasons discussed above. Note that this second range is associated with the first RTU and can be the same or different from the second range associated with the second RTU introduced in the method 600, for example, as will be understood by those skilled in the art after reading this specification.
[0116] Still reference Figure 6B , the method 630 returns from decision 646 to operation 632 in response to determining that the number of blocks included in the first RTU queue is within the second range of the first RTU queue. As described above, this allows the method 630 to continue monitoring the size of the first and / or second RTU queues. The method 630 may alternatively proceed to decision 648 in response to determining that the number of blocks included in the first RTU queue is not within the second range of the first RTU queue. There, decision 648 includes determining whether the current I / O workload experienced by the storage system is within a third range. As described above, the process of transferring storage blocks between pools is a workload intensive process, thereby potentially having an impact on the performance of the overall system. Therefore, by evaluating the current I / O storage system workload storage blocks when determining whether and / or when to transfer storage blocks between pools, the method 630 is able to target low I / O workloads and reduce the resulting processing impact.
[0117] In response to determining that the current I / O workload experienced by the storage system is within the third range, method 630 returns to operation 632. Alternatively, in response to determining that the current I / O workload experienced by the storage system is not within the third range, method 630 proceeds to operation 650. There, operation 650 includes selecting one of the blocks in the second pool. The block selected in operation 650 will undergo garbage collection processing. Thus, in some methods, the block with the most invalid data among all the blocks in the first pool is selected. However, any other desired factors can be considered in the process of selecting a block in the first pool for garbage collection processing.
[0118] Operation 652 further includes relocating valid data from the selected block in the second pool. In response to relocating valid data from the selected block, operation 654 includes erasing the selected block. Continuing to decision 656, method 630 includes transferring the block from the second pool to a first RTU queue corresponding to the first pool. Again, blocks that are "transferred" between RTU queues and / or pools remain in the same plane and channel of memory (e.g., see Figure 4 ). In other words, while the functional characteristics of a given block may change due to activating and / or deactivating certain bits in each cell therein, the block itself is not physically moved in memory. Rather, in a logical sense, blocks are "transferred" between RTU queues and / or pools. In some approaches, these transfers are indicated in the LPT, block status table, operation log, etc.
[0119] Again, the second pool (along with the second RTU queue) includes memory blocks configured in a multi-bit per cell mode, while the first pool (along with the first RTU queue) includes memory blocks configured in an SLC mode. Therefore, since each of the first and second pools includes memory blocks configured in a different mode, the process of actually transferring the selected blocks in operation 656 includes reconfiguring the blocks. Again, referring temporarily to Figure 6C , any of the sub-processes and / or specific methods described for transferring a given block between a pool and an RTU queue may be used to perform Figure 6B Operation 656.
[0120] Return to reference Figure 6B , method 630 returns from operation 656 to operation 632, for example, so that the size of the first and / or second RTU queues can continue to be monitored. Therefore, method 630 can also successfully adjust the block pool size in real time while maintaining efficient performance of the overall storage system.
[0121] Reference now Figure 7 , shows a data and block flow overview 700 according to one embodiment. Alternatively, the data and block flow overview 700 of the present invention can be implemented in combination with features from any other implementations listed herein, such as those described with reference to other figures, such as Figures 6A-6C However, such data and block flow overview 700 and other data and block flow overviews 700 presented herein may be used in different applications and / or in permutations that may or may not be specifically described in the illustrative embodiments listed herein. Further, the data and block flow overview 700 presented herein may be used in any desired environment. Therefore, Figure 7 (and other figures) should be considered to include any possible arrangement.
[0122] As shown, host writes are received by a data placement module 702, which includes an LEB 704 and an LEB 706, where the LEB 704 consists of one or more storage blocks configured in SLC mode and the LEB 706 consists of one or more storage blocks configured in multi-bit per cell mode. In some methods, new data is first written to the LEBs configured with blocks in SLC mode, thereby allowing the new data to benefit from the lower latency and higher throughput associated with blocks in SLC mode (e.g., compared to blocks configured in multi-bit per cell mode). However, in situations involving high host and internal write loads, the new data can be stored directly in blocks configured in multi-bit per cell mode. Blocks configured in SLC mode are received from a first set of RTU queues 708, while blocks configured in multi-bit per cell mode are received from a second set of RTU queues 710. Each of the first set of RTU queues 708 and the second set of RTU queues 710 includes a plurality of storage blocks 712, each storage block 712 being accumulated in an RTU queue for a different plane and channel 714, for example, as will be understood by one skilled in the art after reading this specification.
[0123] Each of the RTU queues 714 associated with the plane and the channel and included in the first set of RTU queues 708 and the second set of RTU queues 710 is depicted as having a plurality of different thresholds corresponding to the number of memory blocks included in the corresponding RTU queue 714. One of these thresholds is an elevated threshold corresponding to any one of the second ranges described above (e.g., see decisions 616 and 646). Thus, the "elevated" threshold is used in some methods to determine whether the corresponding RTU queue and / or a particular channel has an undesirably low number of memory blocks included therein. In the present embodiment, "high", "low" and "critical" thresholds are also implemented, each representing a different fill level of a corresponding channel in the first set of RTU queues 708 and the second set of RTU queues 710.
[0124] In response to filling a given block or memory with data at the data placement module 702, the LEBs are transferred to a corresponding one of the occupied block queues. Specifically, LEBs configured in SLC mode are transferred to SLC occupied block queue 716, while LEBs configured in multi-bit per cell mode are transferred to multi-bit per cell occupied block queue 718. The number of LEBs included in each of the queues 716, 718 changes over time. Therefore, the amount of information stored in each queue 716, 718 (e.g., its effective size) also changes over time.
[0125] Over time, the LEBs are eventually transferred from the queues 716, 718 to the garbage collector and wear leveler module 720. In some approaches, the LEBs are advanced to the garbage collector and wear leveler module 720 according to standard garbage collection procedures. For example, a LEB may be designated for garbage collection because the data in its blocks become invalid over time (e.g., due to overwrite operations, deletions, etc.). However, in other approaches, the LEBs may be transferred by the garbage collector and wear leveler module 720 according to the above description of the LEBs. Figures 6A-6C In some embodiments, the garbage collector or wear leveler may further select LEBs based on the retention time or number of reads of blocks already seen in the LEB, or the measured RBER.
[0126] The LEBs proceed from the garbage collector and wear leveler module 720 to the data relocation module 722, which sends any valid data extracted from the blocks in the LEB back to the data placement module 702 (as indicated by the dashed arrow line). Thus, the data can be stored in another available LEB of the memory. Thereafter, the block erase module 724 erases the blocks in the LEB. The erase operation may involve specifying a target mode for the blocks.
[0127] Depending on the specified target block mode, the erased blocks are either returned to the RTU queue corresponding to the current mode of the block configuration, or the blocks are reconfigured. For example, an empty block configured in SLC mode is either returned to the RTU 714 in the first group of RTU queues 708, or is reconfigured in multi-bit / cell mode before being placed in the RTU 714 in the second group of RTU queues 710. Similarly, an empty block configured in multi-bit per cell mode is either returned to the RTU 714 in the second group of RTU queues 710, or is reconfigured in SLC mode before being placed in the RTU 714 in the first group of RTU queues 708. Therefore, each block erase module 724 is depicted as having two arrowed lines extending therefrom, each of which represents a possible path for a block to be erased therein. The block erase module 724 may be configured based on the RTU 714 as described above. Figures 6A-6CAny process included in makes a determination whether to return a stored block to a matching RTU queue or to reconfigure the block before adding it to a different RTU queue. Further, the reconfiguration of the block may include an update of the block status table.
[0128] Thus, it can be seen that the various embodiments included herein can successfully adjust the block pool size in real time while maintaining efficient performance of the overall storage system. The efficiency of the system is maintained by ensuring that the pool being reduced does not experience a lack of storage blocks due to resizing, ensuring that the pool being enlarged does not hold too many erased blocks in the RTU, ensuring that the write amplification in the source pool does not increase significantly, and ensuring that the blocks being transferred are eligible for transfer. These pool resizing operations are further performed in the background, thereby having no impact on host I / O latency and throughput, as will be understood by those skilled in the art after reading this specification.
[0129] Some embodiments included herein can also avoid the situation where a given pool is switched to field data writes and / or relocations when the pool is under pressure for a clean (e.g., empty) block. Performance is further improved by utilizing cycles involving low I / O loads. Therefore, when the system is not fully utilized, the block transfer between the pools can be performed in the background without affecting the nominal performance of the system. Further, when determining whether to transfer a block between pools, it is particularly desirable to evaluate both the source location and the target location because it avoids unnecessary processing overhead. This also ensures that the source pool is fully replenished before the block is converted to another pool.
[0130] It should also be noted that although different of these methods have been described herein in the context of two storage block pools, any of these methods can be extended to embodiments having more than two block pools. In such embodiments, the target pool can be determined using a priority, based on user input, by comparing the RTU block level of each respective pool and selecting the pool with the lowest number of RTU blocks, etc.
[0131] The present invention may be a system, method and / or computer program product of any possible degree of technical detail integration. The computer program product may include a computer-readable storage medium (or medium) having computer-readable program instructions thereon for causing a processor to execute various aspects of the present invention.
[0132] Computer readable storage medium can be a tangible device that can retain and store instructions for use by instruction execution devices. Computer readable storage medium can be, for example but not limited to, electronic storage device, magnetic storage device, optical storage device, electromagnetic storage device, semiconductor storage device, or any suitable combination of the above. A non-exhaustive list of more specific examples of computer readable storage medium includes the following: portable computer disk, hard disk, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), static random access memory (SRAM), portable compact disk read-only memory (CD-ROM), digital versatile disk (DVD), memory stick, floppy disk, mechanical encoding device such as punch card or a protruding structure in a groove with instructions recorded thereon, and any suitable combination of the above. Computer readable storage medium as used herein should not be interpreted as a temporary signal itself, such as radio waves or other free propagating electromagnetic waves, electromagnetic waves propagated by waveguides or other transmission media (e.g., light pulses passing through fiber optic cables) or electrical signals emitted by wires.
[0133] The computer-readable program instructions described herein can be downloaded from a computer-readable storage medium to a corresponding computing / processing device via a network (e.g., the Internet, a local area network, a wide area network, and / or a wireless network), or downloaded to an external computer or external storage device. The network can include copper transmission cables, optical transmission fibers, wireless transmissions, routers, firewalls, switches, gateway computers, and / or edge servers. The network adapter card or network interface in each computing / processing device receives the computer-readable program instructions from the network and forwards the computer-readable program instructions to be stored in a computer-readable storage medium in the corresponding computing / processing device.
[0134] The computer-readable program instructions for performing the operation of the present invention can be assembly instructions, instruction set architecture (ISA) instructions, machine instructions, machine-related instructions, microcode, firmware instructions, state setting data, configuration data of integrated circuits, or source code or object code written in any combination of one or more programming languages, including object-oriented programming languages (such as Smalltalk, C++, etc.) and process programming languages (such as "C" programming languages or similar programming languages). The computer-readable program instructions can be executed completely on the user's computer, partially on the user's computer, executed as an independent software package, partially on the user's computer, partially on a remote computer, or completely on a remote computer or server. In the latter case, the remote computer can be connected to the user's computer through any type of network (including a local area network (LAN) or a wide area network (WAN)), or can be connected to an external computer (for example, using an Internet service provider through the Internet). In certain embodiments, the electronic circuit including, for example, a programmable logic circuit, a field programmable gate array (FPGA) or a programmable logic array (PLA) can perform computer-readable program instructions by utilizing the state information of the computer-readable program instructions to personalize the electronic circuit so as to perform various aspects of the present invention.
[0135] The present invention will be described below with reference to the flowchart and / or block diagram of the method, device (system) and computer program product according to the embodiment of the present invention. It should be understood that each box of the flowchart and / or block diagram and the combination of each box in the flowchart and / or block diagram can be implemented by computer readable program instructions.
[0136] These computer-readable program instructions can be provided to a processor of a computer or other programmable data processing device to produce a machine, so that the instructions executed by the processor of the computer or other programmable data processing device create a device for implementing the functions / actions specified in one or more boxes of the flowchart and / or block diagram. These computer-readable program instructions can also be stored in a computer-readable storage medium, which instructions cause the computer, programmable data processing device, and / or other equipment to work in a specific manner, so that the computer-readable storage medium in which the instructions are stored includes a manufactured product containing instructions for implementing aspects of the functions / actions specified in one or more boxes of the flowchart and / or block diagram.
[0137] Computer-readable program instructions may also be loaded onto a computer, other programmable data processing apparatus, or other device, so that a series of operational steps are performed on the computer, other programmable apparatus, or other device to produce computer-implemented processing, so that the instructions executed on the computer, other programmable apparatus, or other device implement the functions / actions specified in or in multiple boxes in the flowchart and / or block diagram.
[0138] The flow chart and block diagram in the accompanying drawings show the architecture, function and operation of the possible implementation of the system, method and computer program product according to different embodiments of the present invention. To this end, each box in the flow chart or block diagram may represent a module, segment or part of an instruction, which includes one or more executable instructions for realizing a specified logical function. In some alternative implementations, the function marked in the box may not occur in the order marked in the figure. For example, the two boxes shown in succession can actually be completed as a step, and are executed simultaneously, substantially simultaneously, in a partially or completely overlapping manner in time, or the boxes can sometimes be executed in the opposite order, depending on the functions involved. It should also be noted that each box in the block diagram and / or flow chart, and the combination of the boxes in the block diagram and / or flow chart can be implemented with a dedicated hardware-based system that performs a specified function or action or performs a combination of dedicated hardware and computer instructions.
[0139] In addition, the system according to different embodiments may include a processor and logic integrated with the processor and / or executable by the processor, the logic being configured to perform one or more of the processing steps described herein. By being integrated with it, it is meant that the processor has logic embedded therein as hardware logic, such as an application specific integrated circuit (ASIC), a field programmable gate array (FPGA), and the like. Processor executable means that the logic is hardware logic; software logic, such as a part of firmware, an operating system, a part of an application; and the like, or some combination of hardware and software logic, which is accessible by the processor and is configured to cause the processor to perform some functions when executed by the processor. The software logic can be stored on local and / or remote memory of any memory type, as known in the art. Any processor known in the art, such as a software processor module and / or a hardware processor, such as an ASIC, an FPGA, a central processing unit (CPU), an integrated circuit (IC), a graphics processing unit (GPU), and the like can be used.
[0140] Figure 8 FIG. 8 shows a network architecture 800 according to one embodiment. Figure 8 As shown, a plurality of remote networks 802 are provided including a first remote network 804 and a second remote network 806. A gateway 801 may be coupled between the remote network 802 and the proximity network 808. In the context of the present network architecture 800, the networks 804, 806 may each take any form, including but not limited to a LAN, a WAN (such as the Internet), a public switched telephone network (PSTN), an internal telephone network, etc.
[0141] In use, gateway 801 acts as an entry point from remote network 802 to adjacent network 808. In this way, gateway 801 can act as a router and a switch, where the router can direct a given data packet arriving at gateway 801, and the switch provides the actual path in and out of gateway 801 for the given packet.
[0142] Also included is at least one data server 814, which is coupled to the adjacent network 808 and can be accessed from the remote network 802 via the gateway 801. It should be noted that the (one or more) data servers 814 can include any type of computing device / groupware. Coupled to each data server 814 are multiple user devices 816. Such user devices 816 can include desktop computers, laptop computers, handheld computers, printers, and / or any other type of device containing logic. It should be noted that in some embodiments, the user device 811 can also be directly coupled to any network.
[0143] A peripheral device 820 or a series of peripheral devices 820 (e.g., a fax machine, a printer, a scanner, a hard drive, a networked and / or local data storage unit or system, etc.) may be coupled to one or more of the networks 804, 806, 808. It should be noted that the database and / or additional components may be used with or integrated into any type of network element coupled to the networks 804, 806, 808. In the context of this specification, a network element may refer to any component of a network.
[0144] According to some embodiments, the methods and systems described herein may be implemented using and / or on a virtual system and / or a system that emulates one or more other systems, such as a UNIX system that virtually hosts a MICROSOFT WINDOWS environment, etc. In some embodiments, such virtualization and / or emulation may be enhanced by using VMWARE software.
[0145] In other embodiments, one or more networks 804, 806, 808 may represent a cluster of systems commonly referred to as a "cloud." In cloud computing, shared resources (such as processing power, peripherals, software, data, servers, etc.) are provided to any system in the cloud on an on-demand basis, allowing services to be accessed and distributed across many computing systems. Cloud computing typically involves Internet connections between systems operating in the cloud, but other technologies for connecting systems may also be used, as known in the art.
[0146] Fig. 9 According to one embodiment, Figure 8 A representative hardware environment associated with user device 816 and / or server 814. Fig. 99 shows a typical hardware configuration of a processor system 900 having a central processing unit 910 (such as a microprocessor) and a plurality of other units interconnected via a system bus 912 according to one embodiment. In some embodiments, the central processing unit 910 may include the above-referenced Figure 2 Any method described by one or more processors 210.
[0147] Fig. 9 The processor system 900 shown includes a random access memory (RAM) 914, a read only memory (ROM) 916, and an I / O adapter 918. According to some embodiments, which are in no way intended to limit the present invention, the I / O adapter 918 may include the above-referenced Figure 2 Any method described for the I / O adapter 218. Still referring to Fig. 9 The processor system 900 of the embodiment of the present invention may include the aforementioned components 914, 916, 918, which may be used to connect peripheral devices (such as a storage subsystem 920) to the bus 912. In some embodiments, the storage subsystem 920 may include a processor system 900 that is compatible with the processor system 900. Figure 2 The storage subsystem 920 may be configured similarly and / or identically to the data storage system 220. In accordance with the present invention, which is by no means intended to limit the present invention, the storage subsystem 920 may include a non-volatile data storage card, for example, in addition to Figure 2 In addition to the RAID controller shown in FIG. , there is an NVRAM memory card, RAM, ROM, and / or some other known type of non-volatile memory.
[0148] Continue to refer Fig. 9 The user interface adapter 922 is used to connect a keyboard 924 , a mouse 926 , a speaker 928 , a microphone 932 , and / or other user interface devices such as a touch screen, a digital camera (not shown), etc. to the bus 912 .
[0149] Processor system 900 further includes a communications adapter 934 that connects processor system 900 to a communications network 935 (eg, a data processing network) and a display adapter 936 that connects bus 912 to a display device 938 .
[0150] Processor system 900 may have an operating system resident thereon, such as MICROSOFT WINDOWS operating system (OS), MACOS, UNIXOS, etc. It should be understood that the preferred embodiment may also be implemented on platforms and operating systems other than those mentioned. The preferred embodiment may be written using JAVA, XML, C and / or C++ languages or other programming languages and object-oriented programming methods. Object-oriented programming (OOP), which is increasingly used to develop complex applications, may be used.
[0151] also, Fig.101 shows a storage system 1000 that implements a high-level (e.g., SSD) storage layer in combination with a low-level (e.g., tape) storage layer according to one embodiment. Note that, according to various embodiments, Fig.10 Some of the elements shown in the figure may be implemented as hardware and / or software. The storage system 1000 may include a storage system manager 1012 for communicating with multiple media on at least one higher storage layer 1002 and at least one lower storage layer 1006. However, in other methods, the storage system manager 1012 may communicate with multiple media on at least one higher storage layer 1002, but not with the lower storage layers. The higher storage layer 1002 may preferably include one or more random access and / or direct access media 1004, such as a hard disk, non-volatile memory (NVM), NVRAM, solid-state memory in an SSD, flash memory, an SSD array, a flash memory array, etc., and / or others indicated herein or known in the art. Figure 3-4 An exemplary architecture of an SSD system is shown, which may be used as a higher storage tier 1002 depending on the desired embodiment.
[0152] Still refer to Fig.10 , the lower storage tier 1006 preferably includes one or more lower performance storage media 1008, including sequential access media (such as tape in a tape drive and / or optical media), slower access HDDs, slower access SSDs, etc., and / or other storage media noted herein or known in the art. The one or more additional storage tiers 1016 may include any combination of storage media desired by the designer of the system 1000. Thus, in some approaches, the one or more additional storage tiers 1016 may include the same Figure 1 to Figure 2 Moreover, any of the upper storage tier 1002 and / or lower storage tier 1006 may include any combination of storage devices and / or storage media.
[0153] The storage system manager 1012 can access the network 1010 (such as Fig.10The storage system manager 1012 may communicate with the storage media 1004, 1008 on the upper storage tier 1002 and the lower storage tier 1006 using a storage area network (SAN) as shown or some other suitable network type. The storage system manager 1012 may also communicate with one or more host systems (not shown) through a host interface 1014, which may or may not be part of the storage system manager 1012. The storage system manager 1012 and / or any other components of the storage system 1000 may be implemented in hardware and / or software, and may utilize a processor (not shown) such as a central processing unit (CPU), a field programmable gate array (FPGA), an application specific integrated circuit (ASIC), etc., for executing commands of a type known in the art. Of course, any arrangement of storage systems may be used, as will be apparent to those skilled in the art upon reading this specification.
[0154] In further embodiments, the storage system 1000 may include any number of data storage layers, and may include the same or different storage memory media within each storage layer. For example, each data storage layer may include the same type of storage memory media, such as HDD, SSD, sequential access media (tapes in tape drives, optical disks in optical disk drives, etc.), direct access media (CD-ROM, DVD-ROM, etc.), or any combination of media storage types. In one such configuration, the higher storage layer 1002 may include most of the SSD storage media for storing data in a higher performance storage environment, and the remaining storage layers including the lower storage layer 1006 and the additional storage layer 1016 may include any combination of SSD, HDD, tape drives, etc. for storing data in a lower performance storage environment. In this way, more frequently accessed data, data with a higher priority, data that requires faster access, etc. may be stored in the higher storage layer 1002, while data that does not have one of these attributes may be stored in the additional storage layer 1016 (including the lower storage layer 1006). Of course, after reading this description, those skilled in the art may design many other combinations of storage media types to implement different storage schemes according to the embodiments proposed herein.
[0155] According to some embodiments, a storage system (e.g., 1000) may include logic configured to receive a request to open a data set, logic configured to determine whether the requested data set is stored in multiple associated parts in a lower storage tier 1006 of the tiered data storage system 1000, logic configured to move each associated part of the requested data set to a higher storage tier 1002 of the tiered data storage system 1000, and logic configured to assemble the requested data set from the associated parts on the higher storage tier 1002 of the tiered data storage system 1000.
[0156] Of course, according to different embodiments, the logic may be implemented as a method or computer program product on any device and / or system.
[0157] It is obvious that the different features of the aforementioned systems and / or methods can be combined in any way, so as to create multiple combinations from the description presented above.
[0158] The description of various embodiments of the present invention is presented for the purpose of illustration, but is not intended to be exhaustive or limited to the disclosed embodiments. Many modifications and variations will be apparent to those of ordinary skill in the art without departing from the scope of the described embodiments. The terms used herein are selected to best explain the principles of the embodiments, practical applications, or technical improvements to technologies found in the marketplace, or to enable those of ordinary skill in the art to understand the embodiments disclosed herein.
Claims
1. A computer-implemented method for adjusting the size of a block pool in a storage system, include: determining whether the number of blocks included in the first ready-to-use RTU queue is within a first range for the first RTU queue; In response to determining that the number of blocks included in the first RTU queue is within a first range for the first RTU queue, determining whether the number of blocks included in the second RTU queue is within a second range for the second RTU queue; in response to determining that the number of blocks included in the second RTU queue is not within a second range for the second RTU queue, relocating valid data from one of the blocks in the first pool corresponding to the first RTU queue; erasing the blocks in the first pool; as well as transferring the block from the first pool to a second RTU queue corresponding to the second pool, wherein the blocks in the first pool are configured in a single-layer cell (SLC) mode, wherein the blocks in the second pool are configured in a multi-bit per cell mode, and Wherein, transferring the block from the first pool to the second RTU queue corresponding to the second pool comprises: reconfiguring the block from an SLC mode to a multi-bit per unit mode.
2. The computer-implemented method of claim 1 , wherein transferring the chunk from the first pool to the second RTU queue corresponding to the second pool further comprises: include: The reconfigured block is marked for recalibration of its read threshold voltage shift value.
3. The computer-implemented method of claim 1, include: determining whether a current input / output (I / O) workload experienced by the storage system is within a third range; as well as In response to determining that the current I / O workload experienced by the storage system is not within the third range, the chunk is transferred from the first pool to the second RTU queue corresponding to the second pool.
4. The computer-implemented method of claim 1, in, The blocks in the second pool configured in a multi-bit per cell mode are configured in a quad level cell (QLC) mode.
5. The computer-implemented method of claim 1, include: In response to determining that the number of blocks included in the first RTU queue is not within the first range, selecting one of the blocks in the first pool; Relocate valid data from the selected block; Erase the selected block; as well as The selected block is placed in a first RTU queue corresponding to the first pool.
6. The computer-implemented method of claim 5, wherein the selected block is placed in the first RTU queue corresponding to the first pool include: Selected blocks are marked for recalibration of their read threshold voltage shift values.
7. The computer-implemented method of claim 1, include: determining whether the number of blocks included in the second RTU queue is within a first range for the second RTU queue; In response to determining that the number of blocks included in the second RTU queue is within the first range of the second RTU queue, determining whether the number of blocks included in the first RTU queue is within the second range of the first RTU queue; in response to determining that the number of blocks included in the first RTU queue is not within a second range of the first RTU queue, relocating valid data from one of the blocks in the second pool; erasing the blocks in the second pool; as well as The chunks are transferred from the second pool to a first RTU queue corresponding to the first pool.
8. The computer-implemented method of claim 7, wherein transferring the chunk from the second pool to the first RTU queue corresponding to the first pool include: reconfiguring the block from a multi-bit-per-cell mode to an SLC mode; as well as The reconfigured block is marked for recalibration of its threshold voltage shift value.
9. A computer program product comprising a computer-readable storage medium containing program instructions, the program instructions being readable and / or executable by a processor to cause the processor to: The processor determines whether the number of blocks included in the first ready-to-use RTU queue is within a first range for the first RTU queue; In response to determining that the number of blocks included in the first RTU queue is within a first range for the first RTU queue, the processor determines whether the number of blocks included in the second RTU queue is within a second range for the second RTU queue; In response to determining that the number of blocks included in the second RTU queue is not within a second range for the second RTU queue, the processor relocates valid data of one of the plurality of blocks in the first pool corresponding to the first RTU queue; The processor erases the block in the first pool; and the processor transferring the chunks from the first pool to the second RTU queue corresponding to the second pool, in, The blocks in the first pool are configured in a single-level cell (SLC) mode, wherein the blocks in the second pool are configured in a multi-bit per cell mode, and Wherein, transferring the block from the first pool to the second RTU queue corresponding to the second pool comprises: reconfiguring the block from an SLC mode to a multi-bit per unit mode.
10. The computer program product of claim 9, wherein transferring the chunk from the first pool to the second RTU queue corresponding to the second pool further comprises: include: The reconfigured block is marked for recalibration of its threshold voltage shift value.
11. The computer program product of claim 9, wherein the program instructions are readable and / or executable by the processor to cause the processor to: The processor determines whether a current input / output (I / O) workload experienced by the storage system is within a third range; and In response to determining that the current I / O workload experienced by the storage system is not within the third range, transferring, by the processor, the block from the first pool to the second RTU queue corresponding to the second pool.
12. The computer program product of claim 9, in, The blocks in the second pool configured in multi-bit per cell mode are configured in quad level cell (QLC) mode.
13. The computer program product of claim 9, wherein the program instructions are readable and / or executable by the processor to cause the processor to: In response to determining that the number of blocks included in the first RTU queue is not within a first range for the first RTU queue, the processor selects one of the plurality of blocks in the first pool; relocating, by the processor, valid data from the selected block; erasing, by the processor, the selected block; as well as The selected block is placed, by the processor, in the first RTU queue corresponding to the first pool.
14. The computer program product of claim 13, wherein the selected block is placed in the first RTU queue corresponding to the first pool include: The reconfigured selected blocks are marked for recalibration of their threshold voltage shift values.
15. The computer program product of claim 9, wherein the program instructions are readable and / or executable by the processor to cause the processor to: The processor determines whether the number of blocks included in the second RTU queue is within a first range for the second RTU queue; In response to determining that the number of blocks included in the second RTU queue is within a first range for the second RTU queue, the processor determines whether the number of blocks included in the first RTU queue is within a second range for the first RTU queue; In response to determining that the number of blocks included in the first RTU queue is not within a second range of the first RTU queue, the processor relocating valid data from one of the plurality of blocks in the second pool; The processor erases the block in the second pool; and The processor transfers the block from the second pool to a first RTU queue corresponding to the first pool.
16. The computer program product of claim 15, wherein transferring the chunk from the second pool to the first RTU queue corresponding to the first pool include: The processor reconfigures the block from a multi-bit per cell mode to an SLC mode; as well as The processor marks the reconfigured block for recalibration of its threshold voltage offset value.
17. A system, include: a plurality of non-volatile random access memory (NVRAM) blocks configured to store data; as well as A processor and logic integrated with and / or executable by the processor, the logic being configured to: The processor determines whether the number of blocks included in the first ready-to-use RTU queue is within a first range of the first RTU queue; In response to determining that the number of blocks included in the first RTU queue is within a first range for the first RTU queue, the processor determines whether the number of blocks included in the second RTU queue is within a second range for the second RTU queue; In response to determining that the number of blocks included in the second RTU queue is not within a second range for the second RTU queue, the processor relocates valid data from one of the blocks in a first pool corresponding to the first RTU queue; The processor erases the block in the first pool; as well as the processor transferring the chunks from the first pool to the second RTU queue corresponding to the second pool, wherein the blocks in the first pool are configured in a single-layer cell (SLC) mode, wherein the blocks in the second pool are configured in a multi-bit per cell mode, and Transferring the block from the first pool to the second RTU queue corresponding to the second pool includes reconfiguring the block from an SLC mode to a multiple bits per cell mode.
18. The system of claim 17, wherein transferring the block from the first pool to the second RTU queue corresponding to the second pool further comprises: include: The reconfigured block is marked for recalibration of the threshold voltage shift value of the reconfigured block.
19. The system of claim 17, wherein the logic is configured to: The processor determines whether a current input / output (I / O) workload experienced by the storage system is within a third range; and In response to determining that a current I / O workload experienced by the storage system is not within the third range, the processor transfers the block from the first pool to the second RTU queue corresponding to the second pool.
20. The system of claim 17, wherein the logic is configured to: The processor determines whether the number of blocks included in the second RTU queue is within a first range for the second RTU queue; In response to determining that the number of blocks included in the second RTU queue is within a first range for the second RTU queue, the processor determines whether the number of blocks included in the first RTU queue is within a second range for the first RTU queue; In response to determining that the number of blocks included in the first RTU queue is not within a second range of the first RTU queue, the processor relocating valid data from one of the plurality of blocks in the second pool; erasing, by the processor, the blocks in the second pool; as well as The processor transfers the block from the second pool to a first RTU queue corresponding to the first pool.
