Buffer pool maintenance method, system, and computer program

Abstract

To provide improved methods, systems and computer programs that manage a storage system.SOLUTION: A method of managing a storage system 300 includes: detecting a reference to a first page in the storage system; and creating a first candidate block for the first page based on the detecting. The first candidate block includes a continuous series of pages that begins with the first page. The method also includes: monitoring subsequent references to pages within the first candidate block; determining that the first candidate block meets a first set of hot-block requirements; and relocating the first candidate block to a hot-block space 306 in a buffer pool based on the determining, resulting in a first hot-block 322.SELECTED DRAWING: Figure 3A

Description

[Technical Field]

[0001] FIELD OF THE DISCLOSURE This disclosure relates to memory management, and more particularly to identifying data to be transferred between memory hierarchies. [Background technology]

[0002] Some memory systems, such as those that support database operations, contain one or more buffer pools. A buffer pool is an area in a relatively fast tier of memory that holds recently used data. The memory system may move data from the buffer pool to a relatively slower tier of memory if the data has not been used recently. Some memory systems use a "Least Recently Used" list, which builds a list of data blocks in the buffer pool based on how recently they have been used. Such memory systems typically maintain a Least Recently Used list during system operation and, based on this list, transfer data blocks from the buffer pool to a slower tier as needed. Summary of the Invention [Problem to be solved by the invention]

[0003] The present disclosure has been made in view of the above points, and aims to provide an improved method, system, and computer program for managing a storage system. [Means for solving the problem]

[0004] Some embodiments of the present disclosure may be exemplified as a method for managing a storage system. The method includes detecting a reference to a first page in the storage system. The method also includes creating a first candidate block for the first page based on the detecting. The first candidate block may include a contiguous series of pages starting with the first page. The method also includes monitoring subsequent references to pages in the first candidate block. The method also includes determining that the first candidate block satisfies a first set of hot block requirements. The method also includes, based on the determination, relocating the first candidate block to a hot block space in a buffer pool to become the first hot block.

[0005] Some embodiments of the present disclosure may be exemplified as a processor and memory in communication with the processor, the memory including program instructions that, when executed by the processor, cause the processor to perform the methods described above.

[0006] Some embodiments of the present disclosure may also be embodied as a computer program product, which includes a computer-readable storage medium having program instructions embodied therein, which, when executable by a computer, cause the computer to perform the methods described above.

[0007] The above summary is not intended to describe each illustrated embodiment or every implementation of the present disclosure. [Brief explanation of the drawings]

[0008] [Figure 1] 1 illustrates a method for relocating blocks of pages to hot block space in a buffer pool according to an embodiment of the present disclosure. [Figure 2]1 illustrates a method for utilizing a default set of hot block requirements and a relaxed set of hot block requirements, according to an embodiment of the present disclosure. [Figure 3A] 1 illustrates a first diagram of a storage system having hot block space after creating candidate blocks according to an embodiment of the present disclosure. [Figure 3B] 10 illustrates a second diagram of a storage system having hot block space when the hot block requirements of a candidate block are met, according to an embodiment of the present disclosure. [Figure 3C] 10 illustrates a third diagram of a storage system in which candidate blocks are relocated to hot block space according to an embodiment of the present disclosure. [Figure 4] 1 illustrates a method for removing a page from a hot block space according to an embodiment of the present disclosure. [Figure 5] 1 illustrates exemplary major components of a computer system that may be used in accordance with an embodiment. DETAILED DESCRIPTION OF THE INVENTION

[0009] The drawings included in this application are incorporated in and form a part of this specification. They illustrate embodiments of the present disclosure and, together with the description, serve to explain the principles of the present disclosure. The drawings are merely illustrative of particular embodiments and are not intended to limit the disclosure.

[0010] While the invention is amenable to various modifications and alternative forms, specifics of which have been shown by way of example in the drawings and will be described in detail, it will be understood, however, that it is not intended to limit the invention to the particular embodiments described. On the contrary, the invention is intended to cover all modifications, equivalents, and alternatives falling within the spirit and scope of the invention.

[0011] Aspects of the present disclosure relate to memory management, and more particularly to identifying data transferred between memory hierarchies. While the present disclosure is not necessarily limited to such applications, various aspects of the present disclosure may be understood by discussing various examples using this context.

[0012] Many types of computer systems, such as database systems, utilize multiple storage tiers. These computer systems often store large amounts of data that is not frequently needed by the computer system in larger, slower storage tiers (e.g., tape drives, spinning hard disks). Smaller, faster storage tiers (e.g., random-access memory (RAM)) often store smaller amounts of data that is frequently or currently needed by the computer.

[0013] Additionally, many of these computer systems utilize methods to facilitate maintaining records of data in relatively slower storage tiers and data in relatively faster storage tiers. For example, some such computer systems utilize "paging," in which data is organized into equal-sized blocks (e.g., a specific number of kilobytes). Rather than maintaining a record of the starting and ending addresses of all data in the faster tier, the storage controller can maintain a record of specific pages that have been relocated from the slower storage tier (e.g., hard disk drive) to the faster storage tier (e.g., RAM, cache).

[0014] Computer systems that utilize paging often maintain a section of a high-speed storage tier reserved for pages being relocated to the high-speed storage tier. This section is sometimes referred to as a buffer pool. For example, a system's RAM may contain a section that can be occupied only by pages being relocated from the system's solid-state drives. When a page is relocated to RAM, it may be placed in the buffer pool.

[0015] Computer systems that maintain paging and buffer pools also often utilize methods for determining which pages in a buffer pool are likely to still be needed in the near future, and which pages in a buffer pool can be relocated to slower tiers of storage. A common method is referred to as a least-recently-used (also referred to herein as "LRU") list of pages. An LRU list of pages may also be referred to herein as an "LRU list" or "LRU chain." In computer systems that utilize an LRU list, the storage controller typically keeps a record of the most recent timestamp (e.g., date and time) that each page in the buffer pool was referenced (e.g., by a query "GetPage" operation). The storage controller typically orders the pages so that the most recently referenced pages are at one end of the LRU list and the least recently referenced pages are at the opposite end of the LRU list. When a page is referenced (i.e., it makes a call to the buffer pool), it is moved to the "most recent" end of the LRU list, and then each page shifts towards the least recently referenced end of the LRU list.

[0016] If the referenced page was not previously in the LRU list, all pages on the LRU list are shifted, typically resulting in the least recently used page being relocated to a slower storage tier. However, if the referenced page is already in the LRU list, the pages in the LRU list are reorganized (e.g., pages that were referenced more recently than the referenced page are shifted, while pages that have not been referenced for a longer period of time than the referenced page remain in the same place).

[0017] Even though a page already in the LRU is referenced and typically does not result in any relocation to or from the LRU list (i.e., the buffer pool), shifting pages in the LRU list still requires system resources. For example, reordering the pages in the list and recording the new order of the pages requires updating the buffer pool directory. This update is sometimes referred to as the buffer pool maintenance latch. On some systems, the buffer pool maintenance latch may not actually contain any data that is being relocated in memory at all. In other words, the pages in the buffer pool themselves are not relocated; rather, they are simply assigned to a different location on the LRU list. Therefore, the resources required to perform this buffer pool maintenance do not result in any real change to the storage system.

[0018] Unfortunately, in some computer systems (e.g., databases with repetitive, cyclical queries), the buffer pool maintenance latch can account for a significant portion of the storage controller's activity maintaining the buffer pool. In these computer systems, the list of pages in the buffer pool may remain relatively similar over time, but the order of those pages in the LRU list may change frequently as different pages in the list are referenced. In these computer systems, the high percentage of resources devoted to the buffer pool maintenance latch results in resources being expended that do not contribute to achieving the purpose of the LRU list or improving buffer pool performance. This is because the purpose of the LRU list is to help determine which page(s) should be relocated from the buffer pool to a slower storage tier when necessary. However, in these computer systems, relocations to slower storage tiers occur relatively infrequently compared to other computer systems. However, the buffer pool maintenance latch is still used quite frequently. Therefore, the same or even greater amounts of resources may be utilized to maintain the LRU list, even though the LRU list may actually be used less frequently than in other computer systems.

[0019] For this reason, computer systems in which many page references refer to pages already located in the buffer pool would benefit from a novel method of configuring the buffer pool, which would preferably reduce the amount of buffer pool maintenance latches for these many page references.

[0020] Some embodiments of the present disclosure address these issues by dividing the buffer pool into two sections (sometimes referred to herein as "spaces"). The first space of the buffer pool is the least recently used space where pages tracked in an LRU list are placed (sometimes referred to herein as the "LRU space"). These pages can be relocated to and from disk using similar means as described above, without any interaction with the second buffer pool space. For example, if a page is referenced in a system with an LRU list of 1,000 pages, it may be relocated to the LRU space of the buffer pool. At that point, it becomes the first most recent page in the LRU list (e.g., page number 1 on the LRU list). However, if the page is not referenced again after an additional 999 unique pages have been referenced, the page becomes the 1,000th most recent page in the LRU list (e.g., page number 1,000 on the LRU list). Therefore, if the LRU space needs more space, this page will be the next page to be relocated from the buffer pool to disk.

[0021] The second space in the buffer pool is referred to herein as the hot block space. Unlike the LRU space, the hot block space stores "blocks" of pages rather than individual pages. A block of pages, as used herein, means a series of contiguous pages of a particular size. For example, if a particular block is five pages long, then all five pages in the block will have adjacent storage addresses (e.g., addresses on a hard disk).

[0022] The hot block section of the space stores blocks classified as "hot." Whether a block is "hot" or not is intended to indicate how actively the computer system is using those pages. For a block to be considered a hot block, a certain set of hot block requirements regarding the system's page reference patterns must be met. For example, a typical set of hot block requirements could be a threshold number of page references within that block. In other words, a threshold number of pages in the block must be referenced within a certain time period. For example, a set of hot block requirements could be that 70% of the pages in the block are referenced. Thus, in a 10-page block, if six pages are referenced, it is not considered hot. However, when the seventh page in the block is referenced, the set of requirements is met and the block is considered hot. All of the pages in the block can then be relocated to the hot block space of the buffer pool. Also, any pages in the block that were previously placed in the LRU space up to that point may be relocated to the hot block space of the buffer pool.

[0023] Pages in a hot block may then remain in the hot block space in the buffer pool until the block is no longer considered hot enough. For example, if the average reference time for pages in a "hot" block drops below a threshold (e.g., two references every 10 seconds), the block may be removed from the hot block space. Pages within the block may then be separated based on how recently they were referenced. For example, when relocating a 32-page block from a hot block, the five most recently referenced pages may be relocated to the LRU space, while the remaining 27 pages that have not been referenced recently may be relocated to a slower tier of storage.

[0024] Pages in hot blocks are stored in the hot block queue, but they are not placed in LRU space. Therefore, there is no need to reference them in the LRU list. For that reason, there is no need to reorganize the LRU list when referencing pages in the hot block space, and as a result, no buffer pool maintenance latches are performed. In systems with several blocks of adjacent pages that are referenced quite regularly, this can result in a significant performance improvement.

[0025] However, different systems with different patterns of activity (e.g., typical queries), database sizes, and user preferences may benefit from hot block space to varying degrees. For this reason, some embodiments of the present disclosure may make some aspects of the hot block space configurable. For example, the sizes of the hot block space and the LRU space may be configurable. Thus, users of a system that references the same pages very frequently, rather than all pages in the system with equal frequency, may benefit from an increased size of the hot block space and a decreased size of the LRU space. The size of the blocks may also be configurable. Thus, blocks for very large databases with many subsequent pages may be set larger than blocks for smaller databases. The set of hot block requirements may also be customizable as well. Thus, a user who is particularly concerned about wasting buffer pool space by introducing pages in blocks that are not referenced may set a strict set of requirements, while a user who is particularly concerned about avoiding unnecessary LRU maintenance may set a relaxed set of requirements. The requirements may take different forms as well. For example, a system may require that a certain percentage of pages in a block be referenced multiple times, or that a certain percentage of pages in a section of the block (e.g., the first half of the block) be referenced. Some sets of requirements may be met based on the reference patterns of other blocks. For example, a hot block requirement may require that a certain percentage of pages in the previous adjacent block be referenced.

[0026] 1 illustrates a method 100 for relocating a block of pages to hot block space in a buffer pool according to an embodiment of the present disclosure. Method 100 may be performed, for example, by a storage controller of a computer system, a central processing unit within a computer system, a host of a computer system, or a hypervisor of a system. For purposes of this description, operations of method 100 are referred to as being performed by the "system." Method 100 begins at operation 102, where the system detects a referenced page. As previously discussed, this is often the result of a "get page" operation of a query, although other page reference operations are possible.

[0027] Once the address of the page is found, a candidate block is created for this page in operation 104. As used herein, a candidate block is a hypothetical block that contains the referenced page as its first page. The size of the candidate block may be equivalent to the size configured for the hot block in that portion of the system (e.g., for the database in which the data in the referenced page is located). Thus, if the hot block consists of 16 pages, operation 104 may include creating a candidate block that includes the referenced page and 15 pages following that page's location (e.g., the location of the referenced page on a hard disk).

[0028] The system may then monitor the pattern, which is configured to determine whether pages in the candidate block meet any hot block requirements in the remainder of method 100. The referenced page in the candidate block and any subsequently referenced pages may be temporarily relocated to LRU space upon reference, but the system may still monitor the block references as if the pages were still contiguous.

[0029] Thus, the system may monitor page references for the candidate block in operation 106 and may detect subsequent page references within the candidate block in operation 108. For example, in operation 108, the system may detect a reference to the second page within the candidate block (i.e., the page immediately following the page referenced in operation 102), or to several pages thereafter.

[0030] Upon detecting a subsequent page reference in operation 108, the system determines whether the hot block requirements for the candidate block are met in operation 110. In some embodiments, this may involve comparing the system's page reference patterns with the required reference patterns for the candidate block. These hot block requirements may vary based on implementation and system administrator preferences.

[0031] For example, when utilizing smaller blocks (i.e., when the candidate blocks created in operation 104 are small), a relaxed set of requirements (e.g., a set of requirements that are easy to meet) may be more desirable because moving the small blocks to the hot block space will not take up a large amount of space in the buffer pool. On the other hand, when utilizing larger blocks, a strict set of requirements (e.g., a set of requirements that are difficult to meet) may be more desirable to avoid the risk of blocks whose pages are not actually used frequently taking up a large amount of buffer pool storage.

[0032] Similarly, some users (e.g., database owners, database operators, system administrators) may be particularly focused on avoiding running out of buffer pool space and may therefore choose to move entire blocks into the hot block space only if a strict set of requirements are met, while other users may be particularly focused on avoiding unnecessary LRU space maintenance and may therefore choose to move blocks into the hot block space as soon as a relaxed set of requirements are met.

[0033] In some embodiments, operation 110 may utilize a rather simple set of requirements. For example, a hot block requirement may require that 50% of the pages in a candidate block be referenced within a particular time period (e.g., 1 minute). In some embodiments, the set of requirements may take a more complex form. For example, a hot block requirement may require that at least 30% of the pages in a candidate block be referenced the first time, at least 10% of the pages in a candidate block be referenced the second time, and at least two adjacent pages in the candidate block be referenced in sequence.

[0034] If the system determines in operation 110 that the hot block requirements are not met, the system may return to operation 106 and continue monitoring page references to the candidate block. However, if the system determines that the hot block requirements are met, the system proceeds to relocate pages in the candidate block to the hot block space in operation 112. At this point, the candidate block may be referred to as a "hot block."

[0035] In some cases, operation 112 may include moving some pages previously relocated to the LRU space to the hot block space. In some embodiments, this relocation may be a logical relocation but may not actually involve moving pages within the block to a different physical location in memory. Rather, the system may simply classify pages within the hot block that are "relocated" from the LRU space to the hot block space as being in the hot block space and may remove them from the LRU list. Notably, in a typical storage system, any pages within the hot block that were previously located on disk (e.g., unreferenced pages) are relocated from a slower tier of storage (e.g., a hard disk drive) to the memory where the hot block space is located.

[0036] Once the hot block is relocated to the hot block space in operation 112, the system updates the buffer pool directory in operation 114. This is performed to allow the system to track the pages within the hot block. The detailed information required can vary based on the embodiment, but in a typical embodiment, this information should provide the system with a way to calculate the size of the hot block and its memory address. For example, the buffer pool directory may identify the memory address of the first page in the hot block and the number of pages in the hot block. With that information, the system can locate the hot block in memory and calculate the memory location of each subsequent page in the hot block based on the system's page size. Furthermore, the system can also calculate the end of the hot block based on the number of pages in the hot block. Other information that may be included in the directory includes the end of the block in memory, the size of the block (e.g., megabytes), the identification of the first page, and the identification of the last page.

[0037] Once a hot block is relocated to the hot block space in the buffer pool, the system may subsequently monitor the hot block's page reference patterns and retain the hot block in the hot block space until it no longer qualifies as "hot." The requirements for remaining "hot" may vary based on the embodiment and implementation, and are described in relation to Figure 4.

[0038] Method 100 discloses relocating a single candidate block and using a single set of hot block requirements. However, in some embodiments, it may be beneficial to utilize multiple sets of hot block requirements to facilitate relocating several candidate blocks to hot block space in a short period of time. This may be beneficial, for example, if a query references 100 pages, but the system's block size is 25 pages. In this example, the system may end up relocating four (or more) hot blocks associated with the query in a short period of time. For example, if the first page of the 100 pages is referenced, a 25-page candidate block may be created. 20 of those 25 pages in the candidate block may be referenced by the query, which may be sufficient to satisfy the hot block requirements. The same may then be true for the next candidate block, resulting in five candidate blocks being relocated to hot block space. In some implementations, it is quite common for queries executed by the system to reference more pages than may fit within a candidate block, resulting in many situations where multiple adjacent candidate blocks are relocated to the hot block space.

[0039] In these situations, it can be beneficial to relax the hot block requirements for a candidate block if the candidate block is located immediately after the block is relocated to storage. Thus, in the previous example, if the hot block status of a previous candidate block (i.e., the first candidate block) is expected to increase the likelihood that a second candidate block (e.g., the block associated with pages 20-40 of the query) will become a hot block, it can be beneficial to use a less stringent set of hot block requirements for the second candidate block. This allows the system to relocate subsequent candidate blocks (e.g., candidate blocks 2-5) to the hot block space after fewer page references, reducing the number of LRU space maintenance operations (e.g., buffer pool maintenance latches) before the candidate blocks are relocated.

[0040] The degree to which the set of requirements must be relaxed may depend on the embodiment and implementation. For example, utilizing a very relaxed set of requirements for subsequent candidate blocks may avoid a maintenance latch, but may also increase the likelihood of relocating a candidate block into the hot block space that is not actually "hot." For example, if a first candidate block has 16 pages and all 16 pages are referenced consecutively by a query, the chances that the query will reference a significant number of pages in the second candidate block (e.g., the block adjacent to the 16th page, starting on the 17th page) may also increase, causing this block to become "hot." However, setting a very relaxed hot block requirement for the second candidate block (e.g., a requirement that the first two pages be referenced) may result in the second candidate block being relocated into the hot block space even if the query references only the first three pages of the second candidate block. In this situation, the penalty of storing the entire 16-page block in hot block space may outweigh the benefit of relocating the second candidate block (e.g., avoiding a potential maintenance latch by storing the first three pages of the second candidate block in LRU space).For this reason, the hot block requirements for subsequent blocks may need to be customized for each system and each situation in order to maximize the benefit gained by avoiding a maintenance latch while minimizing the risk of unnecessarily occupying buffer pool space with a "hot block" that only contains a very small percentage of hot pages.

[0041] 2 illustrates a method 200 for utilizing a set of default and relaxed hot block requirements in accordance with an embodiment of the present disclosure. Similar to method 100, method 200 may be performed by, for example, a storage controller of a computer system, a central processing unit within a computer system, a host of a computer system, or a hypervisor of a system. For purposes of this description, the operations of method 200 are referred to as being performed by a "system."

[0042] Method 200 begins at operation 202, where the system monitors page references. The page references monitored at operation 202 cause the system to detect that a first candidate block meets a default set of requirements for a hot block at operation 204. For example, the default set of requirements may specify that a candidate block becomes hot if 50% of its pages are referenced. Thus, in this example, the system detects at operation 204 that 50% of the pages in the first candidate block are referenced.

[0043] As a result of detecting the first hot block in operation 204, the system relocates the first hot block to hot block space in the buffer pool in operation 206. As previously described, this may include relocating some of the pages of the first hot block from another tier of storage and relocating some of the pages of the first hot block from the LRU space.

[0044] After detecting the first hot block in operation 204, the system also continues monitoring page references in operation 208, which may be similar to the operations in operation 202. In some embodiments, operation 208 may be performed consecutively to operation 202. For example, the system may monitor page references throughout the process of method 200. The page references monitored in operation 208 cause the system to detect a second hot block in operation 210 using a first set of relaxed hot block requirements. In some embodiments, the first relaxed hot block requirements may be similar to, but less stringent than, the default hot block requirements utilized in operation 204. For example, the default hot block requirements may require 50% of the pages of the first candidate block to be referenced, while the first relaxed hot block requirements may require 40% of the pages of the second candidate block to be referenced. Similarly, the first relaxed set of hot block requirements may require that the first 50% of the pages in the second candidate block be referenced (i.e., the requirements may require that 25% of the pages in the second candidate block be referenced if 25% of them are in the first half of the second candidate block). In other embodiments, the form of the first relaxed set of hot block requirements may differ from the default requirements. For example, the first relaxed set of requirements may require that 10% of the pages in the second candidate hot block be referenced twice.

[0045] After detecting the second hot block in operation 210, the system relocates the second hot block to the hot block space in operation 212 and continues monitoring page references in operation 214. The monitored page references in operation 216 cause the system to detect a third hot block using a second relaxed set of hot block requirements in operation 216. In some embodiments, the second relaxed set of hot block requirements may take a form similar to the default requirements and the first relaxed requirements. For example, if the default requirements require 50% of the pages in a first candidate block to be referenced and the first relaxed set of requirements require 25% of the pages in a second candidate block to be referenced, the second relaxed set of requirements may require 15% of the pages in a third candidate block to be referenced.

[0046] In some embodiments, the second set of relaxed hot block requirements may take a different form than the default hot block requirements and the first set of relaxed hot block requirements. For example, the default hot block requirements may require that 50% of the pages in the first candidate block be referenced, and the first set of relaxed hot block requirements may require that 50% of the first 50% of the pages in the second candidate block be referenced. However, the second set of relaxed requirements may not be related to pages in the third candidate block. Rather, the second set of relaxed requirements may require that 50% of the second 50% of the pages in the second candidate block be referenced. This may be useful, for example, to take advantage of a tendency for a significant proportion of the pages in both the first and second candidate blocks to be referenced. In situations where these trends exist, it may be highly likely that the third candidate block can also be a candidate block. Therefore, it may be beneficial to relocate the third candidate block to hot block space before any of its pages are referenced.

[0047] Regardless of the form that the second relaxed set of hot block requirements takes, the system may relocate the third hot block into the hot block space in operation 218 as a result of detecting the third hot block in operation 216. In some embodiments of method 200, this results in the first, second, and third hot blocks occupying adjacent positions in the buffer pool, efficiently creating one long series of related pages that may be frequently accessed without maintaining an LRU list.

[0048] For purposes of understanding, Figures 3A-3C illustrate an abstracted representation of a storage system 300 utilizing some embodiments of the present disclosure. It is important to note that the elements illustrated in Figures 3A-3C are shown solely for purposes of understanding, not for purposes of precision. As such, the elements are illustrated as a basic representation of the components of a storage system. However, the number and size of the elements are not necessarily intended to represent an exact reduction to practice embodiments of the present disclosure.

[0049] FIG. 3A illustrates a first diagram of a storage system 300 having a hot block space after candidate block creation, according to an embodiment of the present disclosure. Storage system 300 includes a lower tier of storage 302, such as a hard disk drive, tape drive, or solid-state drive. Storage system 300 also includes an LRU space 304 and a hot block space 306, both of which are located within a buffer pool of a higher tier of storage, such as random access memory or a cache. Lower tier storage 302 includes multiple pages, such as pages 308, 310, and 312. LRU space 304 includes eight pages, such as pages 314, 316, 318, and 320, as illustrated. Hot block space 306 includes a single hot block 322 and is represented by six pages enclosed by dotted line 324. Thus, hot block 322 may come from a section of storage system 300 where the default block size is six pages.

[0050] In some embodiments, the size of hot block space 306 and the size of LRU space 304 may be configurable based on system characteristics and user preferences. A database that tends to run queries in which many pages are called in sequence may benefit from a larger hot block space. A database that tends to run queries in which the majority of queries reference only a few pages, reference pages that are not near each other, or reference pages without any particular pattern may benefit from a larger LRU space and a smaller hot block space.

[0051] For clarity, in Figures 3A-3C, the shading indicates the length of time since a page was referenced, and such pages are shaded. For example, page 314 in LRU space 304 is shaded in a dark color, indicating that it was referenced recently. However, page 316 and pages in hot block 322 are shaded in a slightly less dark color, indicating that they have not been referenced for slightly longer than page 314. Furthermore, pages 318 and 320 are shaded in a lighter color, indicating that they have not been referenced for a longer period of time than pages 314 and 316. On the other hand, pages 308 and 312 are not shaded, indicating that they have not been referenced.

[0052] However, page 310 in lower tier storage 302 has been referenced recently. Therefore, page 310 is shown shaded in a darker color. Additionally, candidate block 326 has been created for page 310 and is shown by dotted line 324. As shown, candidate block 326 includes four pages, starting with page 310. Thus, unlike hot block 322, candidate block 326 may come from a section of storage system 300 where the block size is four pages.

[0053] 3B illustrates a second diagram of a storage system with hot block space when the hot block requirements of a candidate block have been met, according to an embodiment of the present disclosure. In FIG. 3B, page 310 has been relocated to LRU space 304, which shifts down pages in LRU space and requires a buffer pool maintenance latch. Thus, page 314 is no longer the most recently referenced page in LRU space 304, page 318 is now the least recently referenced page in LRU space 303, and page 320 has been removed from LRU space 304.

[0054] 3B, page 330, the second page in candidate block 326, is referenced. If the hot block requirement for candidate block 326 requires that 50% of the pages in candidate block 326 be referenced, then the hot block requirement is met. This allows the storage system to relocate pages in candidate block 326 to hot block space 306.

[0055] This relocation is illustrated in FIG. 3C. In FIG. 3C, the storage system relocates a page belonging to candidate block 326 to hot block space 306, resulting in hot block 332. This may involve relocating, for example, page 310 from LRU space 304 and pages 330 and 334 from lower-tier storage 302. Furthermore, page 334 has migrated to hot block space 306 as part of the hot block, even though it has not yet been referenced. As previously mentioned, relocating page 310 from LRU space 304 to hot block space 306 may involve moving page 310 to a different physical location in memory. However, alternatively, this relocation may be merely a logical relocation, where page 310 remains in the same physical space in memory but is recorded as being located in hot block space 306. In some embodiments, this may only be feasible if sufficient space is available in memory adjacent to page 310 for the remainder of the pages in hot block 332.

[0056] Furthermore, this relocation results in an empty slot in LRU space 304. In some embodiments, the storage system can result in page 320 being relocated back to LRU space 304. The storage system can also leave the empty slot in LRU space 304, waiting to fill the empty slot when another page is referenced.

[0057] Finally, because candidate block 326 was relocated to hot block space 306, the system creates a second candidate block, candidate block 336. The system may then monitor system page references and determine whether to relocate candidate block 336 to hot block space 306 based on the same hot block requirements that were applied to candidate block 326 (i.e., hot block 332). Alternatively, the system may apply a relaxed set of hot block requirements to candidate block 336, assuming that candidate block 336 is more likely to become a hot block because its immediate predecessor (i.e., the page in hot block 332) was relocated as a hot block.

[0058] 1-3C illustrate a method and system by which a set of pages can be added as hot blocks to a hot block space in a buffer pool. In some embodiments, once a hot block is added to the hot block space, it remains there until the pages are no longer referenced frequently enough to warrant remaining in the hot block queue. This is sometimes referred to herein as the hot block no longer being active enough. There are several ways in which a hot block can be determined to no longer be active enough, based on the conditions of the computer system and the preferences of the system user. Most embodiments include determining whether the space available for the hot block in the hot block space may outweigh the benefit of avoiding LRU maintenance latches by storing the hot block in the hot block space.

[0059] 4 illustrates a method 400 for removing pages from hot block space according to an embodiment of the present disclosure. Similar to methods 100 and 200, method 400 may be performed, for example, by a storage controller of a computer system, a central processing unit within a computer system, a host of a computer system, or a hypervisor of a system. For purposes of this description, operations of method 400 are referred to as being performed by a "system."

[0060] Method 400 begins at operation 402 by monitoring references to pages in the hot block. This may be performed, for example, by cross-referencing the list of pages in the hot block in the buffer pool directory with the page references performed by the system. Based on these monitored references, the system may determine, at operation 404, whether a section of the hot block is below a hot block threshold. This hot block threshold may take the form of, for example, a threshold number of references over a period of time (e.g., one reference every five seconds). The hot block threshold may be customizable based on system configuration and user preferences. For example, a user who is particularly concerned about using more buffer pool space than necessary may set the hot block threshold relatively high (e.g., two references every four seconds). This may reduce the likelihood that pages in the hot block will remain above the hot block threshold. However, users who are particularly concerned about system efficiency may wish to avoid the LRU maintenance latch while still maintaining rapid access to hot blocks, and may choose to set the hot block threshold relatively low (e.g., one lookup every 15 seconds), thereby increasing the likelihood that pages in the hot block will remain above the hot block threshold.

[0061] In some embodiments, the "section of a block" referenced in operation 404 may refer to the entire hot block. In other words, when making the determination in operation 404, the system may, in some embodiments, average the page references for all pages in the hot block. For example, a hot block may contain four pages, the first three of which have been referenced twice in the last 20 seconds. However, the fourth page has been referenced 14 times in the last 20 seconds. In this example, the system may calculate the average number of references for each page, resulting in an average of four references every 20 seconds for the entire hot block.

[0062] However, in some embodiments, the "section of a block" referenced in operation 404 may refer to an incomplete portion of a hot block. For example, the first 50% of the pages in a hot block may still be referenced very regularly, while the second 50% of the pages in the hot block may still be referenced very infrequently. In this example, operation 404 may include calculating whether the second 50% of the pages in the hot block are below the hot block threshold. In some embodiments, operation 404 may analyze the pages of the hot block to attempt to identify a set of contiguous pages whose average number of references is below the hot block threshold. In some embodiments, operation 404 may also include determining whether a section of a hot block having infrequently referenced pages is large enough to significantly negatively impact the space available in the buffer pool. For example, in a system with a hot block threshold of three references every 10 seconds, if a section of two contiguous pages in a 100-page hot block has not been referenced for more than one minute, the system may ignore the section as not being large enough to be relevant. However, on the same system, if a 20-page contiguous section within a 500-page hot block is referenced an average of three times every 12 seconds, the system can determine that this section is below the hot block threshold.

[0063] If the system determines in operation 404 that no section of the hot block falls below the hot block threshold, the system continues to monitor references to pages within the hot block in operation 402. However, if the system determines that at least one section of the hot block falls below the hot block threshold, the system may create migration groups within the hot block in operation 406. These migration groups may take the form of a set of contiguous pages from the hot block that exhibit similar reference patterns.

[0064] For example, a hot block may contain 10 pages. If the first four pages are referenced an average of two times every five seconds, the fifth and sixth pages are referenced an average of two times every 16 seconds, and the seventh through tenth pages are referenced an average of once every 50 seconds, the system may form three migration groups. The first migration group may include the first four pages, the second migration group may include the fifth and sixth pages, and the third migration group may include the seventh through tenth pages. Forming migration groups based on the reference patterns of adjacent pages may be useful because it may be beneficial to migrate different sets of pages to different locations (e.g., to LRU space or to hard disk).

[0065] However, as previously described, in some embodiments of method 400, the system may consider the page references of all pages in a hot block together (e.g., on average for the hot block) when determining whether a section of the hot block is below the hot block threshold in operation 404. In some of these embodiments, the system may still create migration groups in operation 406. For example, the system may determine in operation 202 that a 10-page hot block, whose first seven pages are above the hot block threshold but whose last three pages are significantly below the hot block threshold, is, on average, below the hot block threshold. The system then creates two migration groups in operation 406: a first migration group may include the first seven pages and a second migration group may include the last three pages.

[0066] However, in other such embodiments, the system may not create a migration group in operation 406. Rather, if the average reference time for all pages in a hot block is found to be below the hot block threshold, the system may treat the entire block as being below the hot block threshold.

[0067] Forming migration groups for different combinations of hot block pages can provide different benefits depending on system characteristics and user preferences. For example, a migration group formed from the entire hot block may allow pages in the hot block to be relocated more quickly because only one destination may be involved. However, if the hot block contains a series of contiguous non-"hot" pages, especially at the end of the hot block (e.g., the last 10 pages in a series of 30 hot pages), creating a migration group containing those exact non-"hot" pages may allow the system to migrate these non-"hot" pages away from the other pages.

[0068] At the other extreme, migration groups may also be formed solely by individual pages. Thus, a hot block of 10 pages may result in 10 migration groups. This can be beneficial, for example, in hot blocks where there are no large contiguous series of pages above or below the hot block threshold. If the reference pattern of pages within a hot block is uniformly distributed across pages and appears random, it can be beneficial to treat each individual page as a migration group.

[0069] Therefore, the granularity of migration groups can be fine-tuned depending on the situation. In some embodiments, if the number of pages below the hot block threshold is randomly distributed within a hot block, individual non-hot pages can be beneficial. However, while individual non-"hot" pages use only a small amount of storage, relocating them individually to disk or to LRU space can complicate the maintenance of records in the LRU space or the hot block space. For example, in a 40-page block, if five pages are deleted to disk, the result could be six hot blocks, each approximately six pages long.

[0070] Once the migration groups are created in operation 406, destinations for the migration groups are calculated in operation 408. These destinations may represent locations where each migration group will be placed. The migration destinations may be determined, for example, by comparing the average reference time of the migration group to the reference time of the LRU list. However, these destinations may also be based on individual reference times by comparing the reference time of each page to the reference time of each page in the LRU. While this may be beneficial in increasing the chances that a page (or series of pages) will get its appropriate destination, it may also consume significant system resources and cause slowdowns. For example, in an LRU space with 10,000 pages, comparing each migration group to the reference time of each of the 10,000 pages may take a long time.

[0071] Thus, in some embodiments of operation 408, the system can determine an average position within (or outside) the LRU to relocate the migration group. The granularity of these average positions can vary depending on how much the user values ​​system efficiency (e.g., reduced maintenance latches) versus ensuring that each page in the hot block is relocated to exactly the appropriate position. For example, the base average position can be determined by comparing the migration group's average reference time with the highest and lowest reference times of the pages in the LRU list. If the migration group's average reference time is between those two times, the destination can be based on the relative proximity of the average reference time to the two times on the LRU list. For example, if the highest reference time on the LRU list is 110 seconds ago, the lowest reference time on the LRU list is 10 seconds ago, and the migration group's average reference time is 60 seconds ago (i.e., halfway between the two times on the LRU list), the migration group's destination can be the midpoint of the LRU list.

[0072] On the other hand, more complex average positions can be determined by dividing the LRU into smaller sections. For example, the LRU may be divided into quartiles (e.g., four equal contiguous pages). In this example, determining the average position of a migration group may first require determining the quartile in which to place the migration group. This may be done, for example, by comparing the reference time of the migration group for each start and end page of each LRU quartile. Subsequently, operation 408 may also determine the approximate difference between the reference time of the migration group and each start and end page, and estimate the appropriate position in the quartile based on this difference.

[0073] In some embodiments, operation 408 may involve a fairly simple decision. For example, in some embodiments, operation 408 may involve identifying the most recently referenced page of the LRU and preparing to move the migration group to immediately before the most recently referenced page.

[0074] Once the migration group destination locations are determined in operation 408, operation 410 relocates the migration groups to their corresponding destinations. For example, in operation 406, a 20-page hot block may be subdivided into five migration groups. The first and fifth migration groups may have very recent average reference times, the second migration group may have a slightly more recent average reference time, the third migration group may have a slightly more distant average reference time, and the fourth migration group may have a very distant average reference time. In this example, operation 410 may include relocating the second migration group near the “head” of the LRU space (i.e., moving the migration group to the LRU space and adding this migration group near the head of the LRU list, i.e., the most recent section). Furthermore, operation 410 may also include relocating the third migration group near the “end” of the LRU space (i.e., the space of the LRU list opposite the “head” of the LRU list) and relocating the fourth migration group to a slower tier of storage. In this example, operation 410 may also include retaining the first and fifth migration groups in the hot block space, resulting in two partial hot blocks.

[0075] Once the migration group is updated in operation 410, the buffer pool directory is updated in operation 412. The nature of the buffer pool directory update may depend on the migration performed in operation 410. For example, if a partial hot block remains in the hot block space (e.g., the first and fifth migration groups described above), the system may update the hot block entry to take into account, for example, the reduced number of pages in the hot block. In some cases, this may also include creating a second hot block entry (e.g., for the fifth migration group described above).

[0076] In some embodiments, the buffer pool directory may be updated to take into account which pages have been relocated to the LRU and their positions within the LRU. Additionally, the buffer pool directory may be updated to take into account pages within a migration group that have been relocated to a slower storage tier. In other words, operation 412 may determine which pages have been removed from the buffer pool and update the buffer pool directory to no longer include entries for those pages.

[0077] FIG. 5 illustrates representative major components of an exemplary computer system 501 that can be used in accordance with embodiments of the present disclosure. The specific components illustrated are provided for illustrative purposes only and do not necessarily represent the only such variations. Computer system 501 may include a processor 510, memory 520, an input / output interface (also referred to herein as I / O (Input / Output) or I / O interface) 530, and a main bus 540. Main bus 540 may provide a communication path for other components of computer system 501. In some embodiments, main bus 540 may be connected to other components, such as a dedicated digital signal processor (not shown).

[0078] The processor 510 of the computer system 501 may include one or more CPUs 512. The processor 510 may further include one or more memory buffers or caches (not shown) that provide temporary storage of instructions and data for the CPU 512. The CPU 512 may execute instructions on input provided from the cache or memory 520 and output results to the cache or memory 520. The CPU 512 may include one or more circuits configured to perform one or more methods consistent with embodiments of the present disclosure. In some embodiments, the computer system 501 may include multiple processors 510, which is typical of relatively large systems. However, in other embodiments, the computer system 501 may be a single processor with a single CPU 512.

[0079] The memory 520 of the computer system 501 may include a memory controller 522 and one or more memory modules (not shown) for temporarily or permanently storing data. In some embodiments, the memory 520 may include a random-access semiconductor memory, storage device, or storage medium (either volatile or non-volatile) for storing data and programs. The memory controller 522 may communicate with the processor 510 and facilitate the storage and retrieval of information in the memory module. The memory controller 522 may communicate with the I / O interface 530 and facilitate the storage and retrieval of input or output in the memory module. In some embodiments, the memory module may be a dual in-line memory module.

[0080] The I / O interface 530 may include an I / O bus 550, a terminal interface 552, a storage interface 554, an I / O device interface 556, and a network interface 558. The I / O interface 530 may connect the main bus 540 to the I / O bus 550. The I / O interface 530 may direct instructions and data from the processor 510 and the memory 520 to the various interfaces of the I / O bus 550. The I / O interface 530 may also direct instructions and data from the various interfaces of the I / O bus 550 to the processor 510 and the memory 520. The various interfaces may include the terminal interface 552, the storage interface 554, the I / O device interface 556, and the network interface 558. In some embodiments, the various interfaces may include a subset of the interfaces described above (e.g., an embedded computer system in an industrial application may not include the terminal interface 552 and the storage interface 554).

[0081] Logical modules present throughout computer system 501, including but not limited to memory 520, processor 510, and I / O interface 530, can communicate failures and changes in one or more components to a hypervisor or operating system (not shown). The hypervisor or operating system can allocate the various available resources within computer system 501 and track the location of data in memory 520 and processes assigned to the various CPUs 512. In embodiments that combine or reconfigure elements, aspects of the functionality of the logical modules may be combined or redistributed. These variations will be apparent to those skilled in the art.

[0082] The present invention may be embodied as a system, method, and / or computer program product embodied at any conceivable level of technical detail. The computer program product may include a computer-readable storage medium or media having computer-readable program instructions therein for causing a processor to perform aspects of the present invention.

[0083] A computer-readable storage medium may be a tangible device that can hold and store instructions for use by an instruction execution device. A computer-readable storage medium may be, for example, but not limited to, an electronic storage device, a magnetic storage device, an optical storage device, an electromagnetic storage device, a semiconductor storage device, or any suitable combination of the foregoing. A non-exhaustive list of more specific examples of computer-readable storage media includes: portable computer diskettes, hard disks, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), static random access memory (SRAM), portable compact disc read-only memory (CD-ROM), digital versatile disk (DVD), memory sticks, floppy disks, mechanically coded devices such as punch cards or raised structures in grooves having instructions recorded thereon, and any suitable combination of the foregoing. As used herein, computer-readable storage media should not be construed as being transitory signals per se, such as radio waves or other freely propagating electromagnetic waves, electromagnetic waves propagating through a waveguide or other transmission medium (e.g., light pulses through fiber optic cable), or electrical signals transmitted over electrical wires.

[0084] The computer-readable program instructions described herein can be downloaded from a computer-readable storage medium to each computing / processing device, or can be downloaded to an external computer or external storage device via a network, such as the Internet, a local area network, a wide area network, and / or a wireless network. The network may include copper transmission cables, fiber optic transmissions, wireless transmissions, routers, firewalls, switches, gateway computers, and / or edge servers. A network adapter card or network interface within each computing / processing device receives the computer-readable program instructions from the network and forwards the computer-readable program instructions for storage on a computer-readable storage medium within the respective computing / processing device.

[0085] Computer-readable program instructions for carrying out operations of the present invention may be either source code or object code written in any combination of one or more programming languages, including assembler instructions, instruction-set-architecture (ISA) instructions, machine language instructions, machine-dependent instructions, microcode, firmware instructions, state setting data, configuration data for integrated circuits, or object-oriented programming languages ​​such as Smalltalk®, C++, etc., and procedural programming languages ​​such as the "C" programming language or similar programming languages. The computer-readable program instructions may execute entirely on the user's computer, partially on the user's computer as a standalone software package, partially on the user's computer and partially on a remote computer, or entirely on a remote computer or server. In the latter scenario, the remote computer may 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 may be connected to an external computer (e.g., through the Internet using an Internet Service Provider). In some embodiments, computer-readable program instructions may be executed by electronic circuitry, including, for example, programmable logic circuitry, a field-programmable gate array (FPGA), or a programmable logic array (PLA), by utilizing state information of the computer-readable program instructions to individualize the electronic circuitry to implement aspects of the present invention.

[0086] Aspects of the present invention are described herein with reference to flowchart illustrations and / or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of the invention. It will be understood that each block of the flowchart illustrations and / or block diagrams, and combinations of blocks in the flowchart illustrations and / or block diagrams, can be implemented by computer-readable program instructions.

[0087] These computer-readable program instructions may be provided to a processor of a computer or other programmable data processing apparatus to create a machine, such that the instructions, executed by the processor of the computer or other programmable data processing apparatus, create means for implementing the functions / acts specified in one or more blocks of the flowcharts and / or block diagrams. These computer-readable program instructions may also be stored in a computer-readable storage medium, capable of directing a computer, programmable data processing apparatus, and / or other device to function in a particular manner, such that a computer-readable storage medium having instructions stored therein comprises an article of manufacture containing instructions that implement aspects of the functions / acts specified in one or more blocks of the flowcharts and / or block diagrams.

[0088] The computer-readable program instructions may also be loaded onto a computer, other programmable data processing apparatus, or other device, causing the computer, other programmable apparatus, or other device to perform a series of operational steps to produce a computer-implemented process, such that the instructions, which execute on the computer, other programmable apparatus, or other device, implement the functions / operations specified in one or more blocks of the flowcharts and / or block diagrams.

[0089] The flowcharts and block diagrams in the figures illustrate the architecture, functionality, and operation of executable implementations of systems, methods, and computer program products according to various embodiments of the present invention. In this regard, each block in a flowchart or block diagram may represent a module, segment, or portion of instructions, including one or more executable instructions for implementing the specified logical function(s). In some alternative implementations, the functions noted in the blocks may occur out of the order noted in the figures. For example, two blocks shown in succession may actually be completed as a single step, may be executed simultaneously, may be executed substantially simultaneously with partial or full time overlap, or the blocks may be executed in the reverse order depending on the functionality involved. It should also be noted that each block in the block diagrams and / or flowchart diagrams, and combinations of blocks in the block diagrams and / or flowchart diagrams, may be implemented by a system based on special-purpose hardware that performs the specified functions or operations or executes a combination of special-purpose hardware and computer instructions.

[0090] The description of various embodiments of the present disclosure has been presented for illustrative purposes, but is not intended to be exhaustive or limited to the disclosed embodiments. Numerous modifications and variations will be apparent to those skilled in the art without departing from the scope and spirit of the described embodiments. The terms used herein have been selected to explain the principles of the embodiments, practical applications or technical improvements to technology found in the market, or to enable others skilled in the art to understand the embodiments disclosed herein. [Explanation of symbols]

[0091] 300 Storage Systems 302 Low-tier storage Page 308 310 pages Page 312 Page 314 316 pages Page 318 320 pages 304 LRU Space 306 Hot Block Space 326 candidate blocks 324 dotted line 322 Hot Block

Claims

1. A method executed by a computer system, comprising: Detecting a reference to a first page in a storage system; generating a first candidate block for the first page based on the detecting, the first candidate block including a contiguous series of pages beginning with the first page; monitoring subsequent references to pages within the first candidate block; determining, based on the monitoring, that the first candidate block satisfies a first set of hot block requirements; based on said determination, relocating said first candidate block to a hot block space in a buffer pool and making it a first hot block; A method comprising:

2. based on said detecting, moving said first page to a least recently used space in said buffer pool; 2. The method of claim 1, wherein said relocating comprises relocating said first page from said least recently used space to said hot block space.

3. 3. The method of claim 1, wherein the first set of hot block requirements includes a requirement that 50% of the pages in the first candidate block are referenced.

4. generating, prior to the rearrangement, a second candidate block for a series of pages adjacent to the location of the first candidate block based on the determining; determining that the second candidate block satisfies a second set of hot block requirements; The method of any one of claims 1 to 3, further comprising: a) determining whether the second set of hot block requirements is relaxed compared to the first set of hot block requirements;

5. 5. The method of claim 4, wherein the second set of hot block requirements includes a requirement that 50% of the first 50% of the pages in the second candidate block are referenced.

6. determining that a first section of the first hot block is below a hot block threshold after the relocation; 6. The method of claim 1, further comprising: based on determining that a first section of the first hot block is below the hot block threshold, relocating the first section to a least recently used (LRU) space within the buffer pool.

7. The method of claim 6 , wherein the first section of the first hot block comprises the entire first hot block.

8. the first section of the first hot block comprises an incomplete portion of the first hot block, and the method further comprises: relocating a second section of the first hot block to a lower tier of storage; maintaining a third section of the first hot block within the hot block space; The method of claim 6 further comprising:

9. 7. The method of claim 6, wherein the first section of the first hot block comprises an incomplete portion of the first hot block, the method further comprising relocating a second section of the first hot block to a lower tier of storage.

10. determining a destination of the first section, wherein the determining the destination of the first section comprises: calculating an average page reference time for the first section; calculating a first relative proximity between the average page reference time and the highest reference time in an LRU list of the LRU space; calculating a second relative proximity between the average page reference time and the lowest reference time in an LRU list of the LRU space; comparing the first relative proximity with the second relative proximity; The method according to any one of claims 6 to 9, comprising:

11. a processor; a memory in communication with the processor, the memory including program instructions configured, when executed by the processor, to cause the processor to perform a method, the method comprising: Detecting a reference to a first page in a storage system; generating a first candidate block for the first page based on the detecting, the first candidate block including a contiguous series of pages beginning with the first page; monitoring subsequent references to pages within the first candidate block; determining, based on said monitoring, that the first candidate block satisfies a first set of hot block requirements; relocating the first candidate block to a hot block space in a buffer pool based on the determination, and making the first candidate block a first hot block; A system including:

12. The method comprises: based on said detecting, moving said first page to a least recently used space in said buffer pool; 12. The system of claim 11, wherein the relocation includes relocating the first page from the least recently used space to the hot block space.

13. The method comprises: generating, prior to the rearrangement, a second candidate block for a series of pages adjacent to the location of the first candidate block based on the determining; determining that the second candidate block satisfies a second set of hot block requirements; 13. The system of claim 11 or 12, further comprising: the second set of hot block requirements being relaxed compared to the first set of hot block requirements.

14. The method comprises: determining that a first section of the first hot block is below a hot block threshold after the relocation; relocating a first section of the first hot block to a least recently used (LRU) space within the buffer pool based on determining that the first section is below the hot block threshold; The system according to any one of claims 11 to 13, further comprising:

15. 15. The system of claim 14, wherein the first section of the first hot block comprises the entire first hot block.

16. the first section of the first hot block comprises an incomplete portion of the first hot block, and the method further comprises: relocating a second section of the first hot block to a lower tier of storage; 15. The system of claim 14, further comprising: maintaining a third section of the first hot block within the hot block space.

17. 15. The system of claim 14, wherein the first section of the first hot block comprises an incomplete portion of the first hot block, the method further comprising relocating a second section of the first hot block to a lower tier of storage.

18. The method further includes determining a destination of the first section, wherein the determining the destination of the first section comprises: calculating an average page reference time for the first section; calculating a first relative proximity between the average page reference time and the highest reference time in an LRU list of the LRU space; calculating a second relative proximity between the average page reference time and the lowest reference time in an LRU list of the LRU space; comparing the first relative proximity with the second relative proximity; The system according to any one of claims 14 to 17, comprising:

19. A computer program comprising: Detecting a reference to a first page in a storage system; generating a first candidate block for the first page based on the detection, the first candidate block including a contiguous series of pages beginning with the first page; monitoring subsequent references to pages within said first candidate block; determining, based on the monitoring, that the first candidate block satisfies a first set of hot block requirements; based on said determination, relocating said first candidate block to a hot block space in a buffer pool to become a first hot block; A computer program for executing the above.

20. The computer program further causes the computer to based on said detecting, moving said first page to a least recently used space in said buffer pool; 20. The computer program product of claim 19, wherein the relocation is to relocate the first page from the LRU space to the hot block space.

21. The computer program further causes the computer to generating, prior to said relocation, a second candidate block for a series of pages adjacent to the location of said first candidate block based on said determination; determining that the second candidate block satisfies a second set of hot block requirements; 21. The computer program product of claim 19 or 20, further comprising: a second set of hot block requirements that are relaxed compared to the first set of hot block requirements.

22. The computer program further causes the computer to determining that a first section of the first hot block is below a hot block threshold after the relocation; relocating the first section of the first hot block to a least recently used (LRU) space within the buffer pool based on determining that the first section of the first hot block is below the hot block threshold; The computer program according to any one of claims 19 to 21, which causes the computer to execute the following:

23. 23. The computer program product of claim 22, wherein the first section of the first hot block comprises the entire first hot block.

24. the first section of the first hot block includes an incomplete portion of the first hot block, and the computer program further causes the computer to: relocating a second section of the first hot block to a lower tier of storage; maintaining a third section of the first hot block within the hot block space; and 23. The computer program product of claim 22, which causes the computer program product to execute the following:

25. The computer program further causes the computer to determine a destination of the first section, and determining the destination of the first section includes: calculating an average page reference time for the first section; calculating a first relative proximity between the average page reference time and the highest reference time in an LRU list of the LRU space; calculating a second relative proximity between the average page reference time and the lowest reference time in an LRU list of the LRU space; comparing the first relative proximity with the second relative proximity; 25. A computer program according to any one of claims 22 to 24, comprising:

Images