US20150293703A1 - Page table including data fetch width indicator - Google Patents
Page table including data fetch width indicator Download PDFInfo
- Publication number
- US20150293703A1 US20150293703A1 US14/253,059 US201414253059A US2015293703A1 US 20150293703 A1 US20150293703 A1 US 20150293703A1 US 201414253059 A US201414253059 A US 201414253059A US 2015293703 A1 US2015293703 A1 US 2015293703A1
- Authority
- US
- United States
- Prior art keywords
- cache
- memory
- page table
- data fetch
- fetch width
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Granted
Links
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F12/00—Accessing, addressing or allocating within memory systems or architectures
- G06F12/02—Addressing or allocation; Relocation
- G06F12/08—Addressing or allocation; Relocation in hierarchically structured memory systems, e.g. virtual memory systems
- G06F12/0802—Addressing of a memory level in which the access to the desired data or data block requires associative addressing means, e.g. caches
- G06F12/0862—Addressing of a memory level in which the access to the desired data or data block requires associative addressing means, e.g. caches with prefetch
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F12/00—Accessing, addressing or allocating within memory systems or architectures
- G06F12/02—Addressing or allocation; Relocation
- G06F12/08—Addressing or allocation; Relocation in hierarchically structured memory systems, e.g. virtual memory systems
- G06F12/0802—Addressing of a memory level in which the access to the desired data or data block requires associative addressing means, e.g. caches
- G06F12/0866—Addressing of a memory level in which the access to the desired data or data block requires associative addressing means, e.g. caches for peripheral storage systems, e.g. disk cache
- G06F12/0873—Mapping of cache memory to specific storage devices or parts thereof
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F12/00—Accessing, addressing or allocating within memory systems or architectures
- G06F12/02—Addressing or allocation; Relocation
- G06F12/08—Addressing or allocation; Relocation in hierarchically structured memory systems, e.g. virtual memory systems
- G06F12/0802—Addressing of a memory level in which the access to the desired data or data block requires associative addressing means, e.g. caches
- G06F12/0877—Cache access modes
- G06F12/0882—Page mode
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F12/00—Accessing, addressing or allocating within memory systems or architectures
- G06F12/02—Addressing or allocation; Relocation
- G06F12/08—Addressing or allocation; Relocation in hierarchically structured memory systems, e.g. virtual memory systems
- G06F12/10—Address translation
- G06F12/1009—Address translation using page tables, e.g. page table structures
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F3/00—Input arrangements for transferring data to be processed into a form capable of being handled by the computer; Output arrangements for transferring data from processing unit to output unit, e.g. interface arrangements
- G06F3/06—Digital input from, or digital output to, record carriers, e.g. RAID, emulated record carriers or networked record carriers
- G06F3/0601—Interfaces specially adapted for storage systems
- G06F3/0602—Interfaces specially adapted for storage systems specifically adapted to achieve a particular effect
- G06F3/0604—Improving or facilitating administration, e.g. storage management
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F3/00—Input arrangements for transferring data to be processed into a form capable of being handled by the computer; Output arrangements for transferring data from processing unit to output unit, e.g. interface arrangements
- G06F3/06—Digital input from, or digital output to, record carriers, e.g. RAID, emulated record carriers or networked record carriers
- G06F3/0601—Interfaces specially adapted for storage systems
- G06F3/0628—Interfaces specially adapted for storage systems making use of a particular technique
- G06F3/0629—Configuration or reconfiguration of storage systems
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F3/00—Input arrangements for transferring data to be processed into a form capable of being handled by the computer; Output arrangements for transferring data from processing unit to output unit, e.g. interface arrangements
- G06F3/06—Digital input from, or digital output to, record carriers, e.g. RAID, emulated record carriers or networked record carriers
- G06F3/0601—Interfaces specially adapted for storage systems
- G06F3/0668—Interfaces specially adapted for storage systems adopting a particular infrastructure
- G06F3/0671—In-line storage system
- G06F3/0673—Single storage device
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F2212/00—Indexing scheme relating to accessing, addressing or allocation within memory systems or architectures
- G06F2212/10—Providing a specific technical effect
- G06F2212/1016—Performance improvement
- G06F2212/1021—Hit rate improvement
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F2212/00—Indexing scheme relating to accessing, addressing or allocation within memory systems or architectures
- G06F2212/28—Using a specific disk cache architecture
- G06F2212/281—Single cache
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F2212/00—Indexing scheme relating to accessing, addressing or allocation within memory systems or architectures
- G06F2212/60—Details of cache memory
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F2212/00—Indexing scheme relating to accessing, addressing or allocation within memory systems or architectures
- G06F2212/60—Details of cache memory
- G06F2212/602—Details relating to cache prefetching
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F2212/00—Indexing scheme relating to accessing, addressing or allocation within memory systems or architectures
- G06F2212/65—Details of virtual memory and virtual address translation
Definitions
- the present invention relates generally to computer systems, and more specifically, to a page table including a data fetch width indicator in a computer system.
- a cache In the field of computing, a cache is a small, fast memory or storage device used to store data or instructions that were accessed recently, are accessed frequently, or are likely to be accessed in the future, by a processor. Reading from or writing to a cache is typically cheaper (in terms of access time and/or resource utilization) than accessing other memory or storage devices in a computer system. Once data is fetched from main memory and stored in the cache, the data can be accessed in the cache instead of re-fetching the data from main memory, saving both time and resources.
- a cache is made up of units of storage referred to as cache lines having a cache line size, and each cache line has an associated cache tag that references the cache line. Data may be fetched from the main memory in units equal to the cache line size for installation in the cache.
- Embodiments include a method, system, and computer program product for a page table including a data fetch width indicator.
- An aspect includes allocating a memory page in a main memory of a computer to an application that is executed by a processor of the computer. Another aspect includes creating a page table entry corresponding to the memory page in the page table. Another aspect includes determining, by a data fetch width indicator determination logic, the data fetch width indicator for the memory page. Another aspect includes sending a notification of the determined data fetch width indicator from the data fetch width indicator determination logic to supervisory software. Another aspect includes setting the data fetch width indicator in the page table entry by the supervisory software based on the notification.
- Another aspect includes, based on a cache miss in a cache memory of the computer corresponding to an address that is located in the memory page, determining the data fetch width indicator in the page table entry associated with the memory page in the page table, and fetching an amount of data from the memory page based on the data fetch width indicator.
- FIG. 1 depicts a computer system with a page table including a data fetch width indicator in accordance with an embodiment
- FIG. 2 depicts a cache memory for use with a page table including a data fetch width indicator in accordance with an embodiment
- FIG. 3 depicts a process flow for memory page allocation using a page table including a data fetch width indicator in accordance with an embodiment
- FIG. 4 depicts a process flow for a data fetch using a page table including a data fetch width indicator in accordance with an embodiment
- FIG. 5 depicts a page table entry including a data fetch width indicator in accordance with an embodiment
- FIG. 6 depicts a counter management module for counter-based wide fetch management in accordance with an embodiment
- FIG. 7 depicts a cache memory and counter management module for counter-based wide fetch management in accordance with an embodiment
- FIG. 8 depicts a process flow counter-based wide fetch management in accordance with an embodiment
- FIG. 9 illustrates a computer program product in accordance with an embodiment.
- Embodiments of page table including a data fetch width indicator are provided, with exemplary embodiments being discussed below in detail.
- Some applications that are executed by a computer system may require a relatively large amount of adjacent data, and benefit from wider (larger) cache lines, while other applications may benefit from narrower (smaller) cache lines, which have more associativity and more index bits (e.g., cache tags). Therefore, a cache may be designed to have a relatively narrow cache line length (for example, 32 bytes or 64 bytes in some embodiments), and fetches to populate cache entries in the cache may correspond to one cache line, or may correspond to multiple cache lines, as needed by the application associated with the cache entry.
- the size of a cache entry is determined based on a data fetch width indicator that is stored in the page table entry for the memory page in the main memory from which the data in the cache entry was fetched.
- the data fetch width indicator may be set in each page table entry when a memory page is allocated for use by an application, and the corresponding page table entry is created in the page table.
- the data fetch width indicator may comprise, in various embodiments, a wide fetch indicator (WFI) that indicates whether wide fetching is enabled for the memory page, and/or a wide fetch factor indicator (WFFI) that indicates a number of cache lines to fetch simultaneously in a data fetch.
- WFI wide fetch indicator
- WFFI wide fetch factor indicator
- the data fetch width indicator in each page table entry may be set by software in some embodiments, based on, for example, a parameter in an MMAP system call; a parameter associated with an application, a library, or other code module; a software algorithm implemented by an application, a program loader, a dynamic optimization module, or supervisory software such as an operating system or a hypervisor.
- the data fetch width indicator in each page table entry is set by hardware based on, for example, a hardware mechanism that identifies whether wide or narrow data fetches are appropriate for a particular memory page.
- a hardware mechanism determines the data fetch width indicator, and sends a notification to the supervisory software to set the data fetch width indicator based on the determination.
- the data fetch width indicator may be set in the page table entry based on a type of the application for which the memory page is allocated. For example, database or high performance computing (HPC) workloads may have a relatively wide data fetch width indicator (e.g., 2 to 4 cache lines per data fetch), while other workloads, such as scripting languages (e.g., for domain-specific languages, or DSLs), may have a relatively narrow data fetch width indicator (e.g., a single cache line per data fetch).
- the data fetch width indicator may be initialized to a default value.
- the behavior of the application associated with a page table entry may be monitored during execution, and the data fetch width indicator in the page table entry may be updated based on the monitoring.
- the monitoring may maintain a counter of a number of times the application has accessed adjacent cache lines, and, based on the counter reaching a threshold, increase the data fetch width indicator in the page table entry associated with the application.
- multiple page table entries in a page table may point to a single physical memory page; in such embodiments, multiple page table entries that point to the same memory page are simultaneously updated when the threshold is reached for the memory page.
- multiple page table entries that point to the same memory page are separately updated when references to the page via a specific page table entry reach the threshold, reflecting possibly different application access patterns via different page table entries.
- the monitoring of application behavior and updating of the data fetch width indicator may be performed in conjunction with a runtime system that is executing the application, such as a just-in-time (JIT) compiler, a dynamic system optimizer, or a dynamic compiler.
- JIT just-in-time
- a dynamic system optimizer such as a dynamic compiler.
- This may avoid direct manipulation of page table entries.
- a runtime system such as a just-in-time (JIT) compiler, a dynamic system optimizer, or a dynamic compiler.
- JIT just-in-time
- a dynamic system optimizer such as a dynamic compiler.
- Linux then synchronizes the PowerVM page table with the software page table after a data fetch width indicator in the software page table has been updated based on reaching the threshold.
- the operating system may track the data fetch width indicators separately from the hardware translation implementation.
- the hardware page tables are managed as a cache, and are not copied back into the operating system page tables. Therefore, direct updates to the hardware page tables will be lost in the course of hardware page table entry replacement. Allowing an update to a data fetch width indicator to be processed by privileged supervisory software gives the software stack the ability to reflect the update in the operating system page table entries.
- the monitoring may be implemented in a hardware module comprising a counter management module that determines updated data fetch width indicators based on identification of whether wide or narrow data fetches are appropriate for a particular memory region, which may comprise one or more memory pages in some embodiments, or a portion of a memory page in other embodiments.
- a counter management module that determines updated data fetch width indicators based on identification of whether wide or narrow data fetches are appropriate for a particular memory region, which may comprise one or more memory pages in some embodiments, or a portion of a memory page in other embodiments.
- single-bit use indicators are provided in each cache line in the cache memory, and the counter management module maintains a count of how often adjacent cache lines were touched based on the use indicators. If the counter for a memory region exceeds a threshold, the data fetch width indicator of the memory region is updated to allow wide fetches, or to increase the fetch size.
- the counter for memory region may be disabled based on one of: enabling of wide fetch for the memory region, elapsing of a predetermined time period since assigning the counter to the memory region, and performing a predetermined number of fetches to the cache memory from the memory region.
- a disabled counter may be reused by a different memory region.
- the counter management module determines a value for a data fetch width indicator for a memory region, and sends a hardware notification to supervisory software of the computer system, and the supervisory software sets the data fetch width indicator for the memory region based on the notification.
- a use indicator may be updated to indicate that a cache line was touched based one or more of a read access of the cache line, a write access of the cache line, and zeroing of the cache line by a dcbz instruction, which comprises instruction that fills a fixed-size chunk of memory with zeroes.
- the dcbz instruction may correspond to a fraction of a cache line in one embodiment, or correspond to an entire cache line in another embodiment.
- the cache memory is divided into blocks of N bytes, and a counter is maintained for each block in each level of cache. For example, in a processor with 3 levels of cache, there are 3 counters for each block.
- a counter(A,L) is a counter associated with a block at address A and cache level L.
- the cache memory is further organized as S sets of E elements each, and the elements are each cache lines having a cache line size (for example, 64 bytes). In this example, if two of those 64-byte cache lines from a contiguous 128 bytes in a memory page are fetched into the cache memory, the two cache lines are located in consecutive sets.
- there may not be one counter per level of cache rather, there may be one counter that is associated with one level of the cache.
- Computer system 100 includes a processor 101 and a main memory 103 .
- Processor 101 includes a cache memory 102 that is used for local storage within processor 101 .
- Processor 101 executes a plurality of applications 105 A-N, which are located in main memory 103 .
- Each of applications 105 A-N has at least one respective allocated memory page(s) 106 A-N that is used to store data corresponding to the application 105 A-N (e.g., memory page(s) 106 A are allocated to application 105 A, etc.).
- Page table 104 is used for address translations from one of the effective or virtual addresses that are used by processor 101 during execution of applications 105 A-N to real addresses in the main memory 103 .
- Each of memory pages 106 A-N has a respective page table entry in page table 104 .
- Each page table entry in page table 104 includes a data fetch width indicator that indicates a width for data fetches from the memory page, such as allocated memory pages 106 A-N, that is associated with the page table entry.
- the data fetch width indicator in each page table entry may vary based on the type of the application 105 A-N that is associated with the memory page(s) 106 A-N that is described by the page table entry.
- Computer system 100 further comprises a data fetch width indicator determination logic 107 , which comprises a hardware mechanism for adjusting a data fetch width indicator in a page table entry in page table 104 , and is discussed below in further detail with respect to FIG. 3 .
- Supervisory software 108 which may comprise one or more of an operating system and a hypervisor, also runs on computer system 100 .
- Computer system 100 further comprises a hardware counter management module 109 in communication with cache memory 102 , which comprises a hardware mechanism for adjusting data fetch width indicators for memory page(s) 106 A-N.
- FIG. 1 is shown for illustrative purposes only; in various embodiments, a computer system may execute any appropriate number of applications such as applications 105 A-N, and may include any appropriate number of levels of cache memory.
- FIG. 2 illustrates an embodiment of a cache memory 200 .
- Cache memory 200 may comprise cache memory 102 of FIG. 1 .
- Cache memory 200 includes a plurality of cache lines 202 A-N, each referenced by a respective cache tag 201 A-N.
- Cache entries such as cache entries 203 - 205 , may comprise one or more of cache lines 202 A-N.
- the number of cache lines in a cache entry such as cache entries 202 - 205 is determined based on the data fetch width indicator that is stored in the page table entry associated with the memory page from which the data in the cache entry was fetched.
- Each of example cache entries 202 - 205 is associated with a memory page in the main memory that has a different respective data fetch width indicator in its page table entry.
- an access to a first portion of a cache entry 203 corresponding to cache line 202 A is performed in conjunction with a tag match of cache tag 201 A; an access to a second portion of a cache entry 203 corresponding to cache line 202 C is performed in conjunction with a tag match of cache tag 201 C; an access to a first portion of a cache entry 204 corresponding to cache line 202 B is performed in conjunction with a tag match of cache tag 201 B; an access to a second portion of a cache entry 204 corresponding to cache line 202 D is performed in conjunction with a tag match of cache tag 201 D; an access to a third portion of a cache entry 204 corresponding to cache line 202 F is performed in conjunction with a tag match of cache tag 201 F; an access to a fourth portion of a cache entry 204 corresponding to cache line 202 H is performed in conjunction with a tag match of cache tag 201 H.
- a hit and miss indication can be separately determined for each cache line that is part of a single cache entry.
- not all cache line constituents of a single cache entry are located in the same associativity class in the cache memory 200 .
- a cache entry may comprise cache line 202 A with associated cache tag 201 A, and cache line 202 D with associated cache tag 201 D.
- a single cache tag is used for an entire entry.
- cache lines 202 A and 202 C in cache entry 203 are referenced by cache tag 201 A;
- cache lines 202 B, 202 D, 202 F, and 202 H in cache entry 204 are referenced by cache tag 201 B;
- cache line 202 E in cache entry 205 is referenced by cache tag 201 E.
- all cache lines of a single cache entry are placed in the same associativity class in the cache memory 200 .
- cache tag matching may be performed using a single cache tag for all the cache lines that make up a cache entry.
- Cache lines 202 A-N may have any appropriate size in various embodiments.
- each of cache lines 202 A-N may be 32 bytes in some embodiments; in such embodiments, cache entry 203 is 64 bytes, cache entry 204 is 128 bytes, and cache entry 205 is 32 bytes.
- each of cache lines 202 A-N may be 64 bytes in some embodiments; in such embodiments, cache entry 203 is 128 bytes, cache entry 204 is 256 bytes, and cache entry 205 is 64 bytes.
- FIG. 2 is shown for illustrative purposes only; a cache memory may have any appropriate number of cache lines and cache entries, and the cache entries may each span any appropriate number of cache lines.
- Each cache line 202 A-N includes a respective use indicator 203 A-N comprising a 1-bit field that indicates whether the cache line has been touched by the processor 101 .
- the associated use indicator is set to untouched (for example, 0); when the cache line is touched by the processor 101 , the associated use indicator is set to touched (for example, 1).
- the cache memory 200 also includes a separate data port 208 that is used to install data in the cache memory 200 and to access data in the cache memory 200 by processor 101 in conjunction with tag match logic (not shown) to determine hits and misses in the cache memory 200 .
- the cache memory 200 further includes a snoop port 207 , which may be used by a tag match logic (not shown) of the computer system to determine hits and misses in the cache memory 200 in order to determine whether remote processor data requests from memory refer to data currently resident in cache memory 200 .
- the counter management module 109 that was shown in FIG. 1 operates in conjunction with data port 208 .
- the counter management module 109 that was shown in FIG. 1 operates in conjunction with snoop port 207 such that the operations of the counter management module 109 do not conflict with data operations concurrently being performed via data port 208 .
- a cache memory may have any appropriate number of cache lines and cache entries, and the cache entries may each span any appropriate number of cache lines.
- the cache memory includes an additional port that is distinct from the snoop and data port and that is used by the counter management module 109 .
- a use indicator of use indicators 203 A-N may be updated to indicate that its respective cache line was touched based one or more of a read access of the cache line, a write access of the cache line, and zeroing of the cache line by a dcbz instruction, which comprises instruction that fills a fixed-size chunk of memory with zeroes.
- the dcbz instruction may correspond to a fraction of a cache line in one embodiment, or correspond to an entire cache line in another embodiment.
- FIG. 3 illustrates an embodiment of a method 300 for memory page allocation using a page table including a data fetch width indicator.
- FIG. 3 is discussed with reference to FIGS. 1 and 2 .
- an application such as application 105 A
- processor 101 executes at least one memory page such as memory page(s) 106 A
- main memory 103 for the application 105 A.
- an initial page table entry including a data fetch width indicator is created in page table 104 for the allocated memory page(s) 106 A.
- the data fetch width indicator may be set in block 302 based on the type of application 105 A.
- the data fetch width indicator may be set in block 302 by software in some embodiments, based on, for example, a parameter in an MMAP system call, a parameter associated with an application, a library, or other code module; a software algorithm implemented by an application, a program loader, a dynamic optimization module, an operating system, or a hypervisor.
- the data fetch width indicator may be set in block 302 to a preferred initial size, such as a maximum cache line size, prior to performing a hardware method for optimizing the cache line size.
- a hardware module comprising a data fetch width indicator determination logic 107 is invoked in the hardware of computer system 100 .
- the data fetch width indicator determination logic 107 is a hardware mechanism that identifies whether wide or narrow data fetches are appropriate for the particular memory page(s) 106 A.
- data fetch width indicator determination logic 107 is invoked with a special instruction.
- the data fetch width indicator determination logic 107 invoked based on writing to, for example, a control register in computer system 100 .
- the writing to the control register provides additional configuration information for use in determining the data fetch width indicator, for example, a threshold for determining a preferred line size, e.g., a number of accesses to be performed before a determination of the data fetch width indicator is made.
- the data fetch width indicator determination logic 107 is invoked based on an initial load of the page table entry into a memory management unit (MMU) translation structure, such as an effective to read address translation (ERAT) or a translation lookaside buffer (TLB). Invoking the data fetch width indicator determination logic 107 causes the data fetch width indicator determination logic 107 to determine an updated data fetch width indicator responsive to workload behavior of application 105 A and current overall system behavior of computer system 100 in block 303 .
- MMU memory management unit
- EAT effective to read address translation
- TLB translation lookaside buffer
- a hardware notification is received indicating that an updated data fetch width indicator has been determined for memory page(s) 106 A.
- the notification comprises a hardware exception to that is received by supervisory software 108 from the data fetch width indicator determination logic 107 .
- the supervisory software 108 comprises an operating system or a hypervisor.
- the updated data fetch width indicator is set in the page table entry for memory page(s) 106 A in page table 104 .
- the supervisory software 108 determines which page table entry in page table 104 corresponds to the notification, and the updated data fetch width indicator is set in the page table entry that corresponds to the notification.
- an invalidation operation is performed to force a subsequent reloading of a page table entry with the updated data fetch width indicator to a translation structure such as an ERAT or TLB.
- two distinct page table representations are present, e.g., a first software page table structured as a radix page table, and a second hardware page table, or hashed page table (HPT), that is maintained as a hashed cache of recently used page translations that is managed by hardware.
- the software page table is directly maintained by the operating system, and the HPT is maintained jointly by an operating system and a hypervisor.
- the software page table is then updated with the hardware-determined data fetch width indicator.
- a hypervisor call is then performed to update a cached value for a data fetch width indicator in the HPT.
- data fetch width indicator determination logic 107 in computer system 100 may directly update at least one page table entry in addition to sending the notification, in order to reduce the overhead associated with performing the processing of a notification event.
- data fetch width indicator determination logic 107 may directly update the data fetch width indicator in at least one translation structure entry (such as an ERAT or TLB entry) in addition to performing a page table update to reduce the overhead associated with synchronizing a data fetch width indicator contained in a translation entry with a page table entry.
- the hypervisor may update the HPT, and further optionally send a notification to the operating system to update a software page table. No synchronization is necessary from the OS to the hypervisor to update the HPT in such an embodiment.
- the data fetch width indicator determination logic 107 is configurable, such that the data fetch width indicator determination logic 107 may perform one or both of sending a notification to the supervisory software 108 , and directly updating at least one of a page table entry and an address translation structure entry (e.g., reflective of a system using two levels of page tables corresponding to software and hardware page tables and utilizing notifications, and a system using a single level of hardware page tables).
- the notification is sent in conjunction with additional algorithms in software, for example, a JIT, a dynamic system optimizer, or dynamic re-compiler to further determine a final data fetch width indicator for a page such as memory page(s) 106 A, giving software additional control over system performance.
- additional algorithms in software for example, a JIT, a dynamic system optimizer, or dynamic re-compiler to further determine a final data fetch width indicator for a page such as memory page(s) 106 A, giving software additional control over system performance.
- multiple page table entries may point to a single physical page in main memory 103 , making it desirable to simultaneously update multiple PTEs when a notification is received.
- block 306 during execution of application 105 A, the execution of the application 105 A is monitored, and the data fetch width indicator in the page table entry corresponding to application 105 A may be updated based on the monitoring by repeating blocks 303 - 305 .
- the monitoring of block 306 occurs in conjunction with invoking of the data fetch width indicator determination logic 107 as described with respect to block 303 , either immediately after the initial determination of the data fetch width indicator, or periodically based on either changes in system workloads and configuration, or after a fixed period of time has lapsed.
- System configuration events that may trigger monitoring may include changes in the number or nature of workloads simultaneously executed by computer system 100 , or changes in system behavior (e.g., cache miss rates, instructions per cycle (IPC), cycles per instruction (CPI), or other such performance indicators) being observed by hardware or a program optimization component.
- the monitoring may comprise maintaining a counter of a number of times the application 105 A accesses adjacent cache lines, and comparing the counter to a threshold to determine whether the data fetch width indicator in the page table entry corresponding to the application needs to be modified.
- FIG. 4 illustrates an embodiment of a method 400 for a data fetch using a page table including a data fetch width indicator.
- FIG. 4 is discussed with reference to FIGS. 1 and 2 .
- processor 101 uses page table 104 to translate one of the effective or virtual address of the cache miss to a real address in memory page(s) 106 A in main memory 103 , and also determines the data fetch width indicator of the memory page where the real address associated with the cache miss is located.
- the data fetch width indicator is located in the memory page's associated page table entry in page table 104 .
- the processor 101 fetches the data associated with the cache miss from the location in the memory page(s) 106 A that is specified by the real address.
- the amount of data that is fetched corresponds to the data fetch width indicator that was determined in block 403 .
- the fetched data comprises a set of cache lines starting at a multiple of the fetch width, i.e., if the cache line size is 32 bytes and the fetch width is 4 cache lines, then the following fetches are executed:
- the mask corresponds to a mask to mask out bits corresponding to a line index within an entry.
- the cache line size is 32 bytes and the fetch width is 128 bytes (4 cache lines), then the MASK value would be 0xFFFFFF80 (binary 0b11111111111111111111111110000000), if the address is expressed as a 32-bit byte address.
- the mask corresponds to (WFFI*CLS), i.e., the two's complement of the wide fetch factor indicator (WFFI) in the page table, or specified elsewhere (e.g., in a boot parameter, SPR, during design time, and so forth), multiplied by the cache line size (CLS).
- WFFI*CLS the two's complement of the wide fetch factor indicator
- the fetch might be expressed as:
- FIG. 5 depicts an embodiment of a page table entry 500 including a data fetch width indicator.
- Page table entry 500 may be stored in page table 104 of FIG. 1 .
- Page table entry 500 of FIG. 5 is a 32-bit entry comprising a plurality of fields 501 - 512 .
- the data fetch width indicator in page table entry 500 comprises wide fetch factor indicator (WFFI) 502 , which is stored in bit 11 and bit 10 , and wide fetch indicator (WFI) 503 , which is stored in bit 9 .
- WFFI 502 indicates how many lines should concurrently be fetched from the memory page associated with page table entry 500
- the WFI 503 indicates whether wide fetch is enabled for the memory page associated with page table entry 500 .
- Bit 31 through bit 12 comprise a page frame address (PFA) 501 .
- Bit 8 comprises a zero field 504 .
- Bit 7 comprises an L field 505 .
- Bit 6 comprises a dirty indicator field 506 .
- Bit 5 comprises an accessed indicator field 507 .
- Bit 4 comprises a page cache disabled indicator field 508 .
- Bit 3 comprises a page write transparent indicator field 509 .
- Bit 2 comprises a user accessible indicator field 510 .
- Bit 1 comprises a writeable indicator field 511 .
- Bit 0 comprises a present indicator field 512 .
- Page table entry 500 is shown for illustrative purposes only; for example, in some embodiments, WFI 503 may be omitted, and a 3-bit WFFI 502 may be provided.
- a page table entry may have any appropriate number of bits and any appropriate number and type of fields.
- the WFFI and WFI are represented by a single field, and one particular WFFI value may indicate no wide fetch.
- WFFI 502 and WFI 503 are stored in a segment tables in conjunction with segment table entries.
- WFFI 502 and WFI 503 are stored in the segment lookaside buffer entries (SLBE) of the segment lookaside buffer (SLB) of the Power ISA.
- one or both of the WFFI 502 and WFI 503 are stored in a caching structure for page translations in hardware so as to accelerate access to the WFFI 502 and WFI 503 .
- the WFFI 502 and WFI 503 are obtained from one of a page table entry (PTE, optionally cached in a TLB) and a segment lookaside entry (SLBE) of a segment lookaside buffer during the address translation process and stored in the effective to real address table for rapid access in conjunction with block 402 of FIG. 4 .
- PTE page table entry
- SLBE segment lookaside entry
- Embodiments of a page table entry including a data fetch width indicator may be implemented in environments based on the PowerPC architecture, also referred to as Power ISA, offered by International Business Machines Corporation (IBM®) and described in the Power ISATM Version 2.06 Revision B specification, Jul. 23, 2010, hereby incorporated by reference herein in its entirety, and may include one or more aspects, as well as computing environments of other architectures, such as the z/Architecture, offered by International Business Machines Corporation, and described in z/Architecture—Principles of Operation, Publication No. SA22-7932-09, 10th Edition, September 2012, which is hereby incorporated by reference herein in its entirety.
- PowerPC architecture also referred to as Power ISA
- IBM® International Business Machines Corporation
- Power ISATM Version 2.06 Revision B specification Jul. 23, 2010, hereby incorporated by reference herein in its entirety
- computing environments of other architectures such as the z/Architecture, offered by International Business Machines Corporation, and described in z/Architecture—Pri
- FIG. 6 illustrates an embodiment of a counter management module 600 .
- Counter management module 600 may comprise counter management module 109 of FIG. 1 .
- Counter management module 600 includes a plurality of counters 601 A-N, and a counter assignment and enable/disable logic 602 .
- the counter management module 600 further includes an interface 603 to a snoop port of a cache memory such as cache memory 102 / 200 , or to another port to cache memory 200 .
- Counter assignment and enable/disable logic 602 assigns counters of counters 601 A-N to memory regions of memory pages 106 A-N that are allocated to applications such as applications 105 A-N, and increments and decrements the counters 601 A-N as needed based on accesses of adjacent lines in the cache memory.
- Counter assignment and enable/disable logic 602 further determines if a counter of counters 601 A-N is above a predetermined threshold, and, based on determining that a counter of counters 601 A-N is above the predetermined threshold, causes a hardware notification to be sent to the supervisory software 108 so that supervisory software 108 may update the data fetch width indicator of memory region of memory page(s) 106 A-N that is associated with the counter.
- Counter assignment and enable/disable logic 602 further determines if a predetermined time period or a predetermined number of fetches have elapsed since the assignment of a counter of counters 601 A-N, and if the predetermined time period or the predetermined number of fetches have elapsed, disables the counter.
- a disabled counter may be reassigned to a subsequent memory region of an application.
- FIG. 6 is shown for illustrative purposes only; a counter management module may include any appropriate number of counters, and may, in some embodiments, be connected to an additional port of the cache memory that is distinct from both the snoop port and the data port.
- counters 601 A-N are stored in a separate counter array.
- a counter is associated with a memory block and may optionally be stored in conjunction with a translation structure for translating addresses of memory blocks that are organized as a cache of recent address translations for blocks of memory.
- FIG. 7 illustrates an embodiment of a counter management module 704 , in conjunction with a cache memory 700 .
- Counter management module 704 may comprise counter management module 109 of FIG. 1
- cache memory 700 may comprise one of a translation lookaside buffer (TLB), a segment lookaside buffer (SLB), and an effective to real address table (ERAT).
- TLB translation lookaside buffer
- SLB segment lookaside buffer
- EAT effective to real address table
- the cache memory 700 comprises a plurality of memory blocks 701 A-N, and a respective counter 702 A-N is maintained in the cache memory 700 for each memory block 701 A-N.
- the memory blocks 701 A-N may be about 4 kilobytes each in some embodiments.
- Each counter 702 A-N may be assigned to addresses in the counter's respective memory block of memory blocks 701 A-N.
- the counters 702 A-N are managed by counter assignment and disable/enable logic 705 in counter management module 704 via port 703 , as described above with respect to counter management module 600 of FIG. 6 .
- FIG. 7 is shown for illustrative purposes only; a cache memory may comprise any appropriate number of memory blocks of any appropriate size, and each memory block may have any appropriate number of associated counters.
- cache memory 700 corresponds to a cache of address translations.
- cache memory 700 comprises a TLB and stores virtual to physical (or real) memory addresses translations.
- each memory block 701 A-N corresponds to a memory page.
- a plurality of memory pages comprise to a single memory block of memory blocks 701 A-N and are associated with a single counter 702 A-N.
- each counter of counters 702 A-N is statically associated with a respective memory block 701 A-N.
- a counter 702 A-N is assigned to a memory bock by counter assignment logic 705 .
- data fetch width indicators are associated with pages translated by the TLB.
- data fetch width indicators are associated with pages translated by the TLB.
- data fetch width indicators are associated with memory blocks comprising multiple memory pages translated by the TLB.
- cache memory 700 corresponds to a SLB and stores effective to virtual memory addresses translations. In one embodiment, such segment address translations are performed in accordance with the Power ISA.
- each memory block 701 A-N corresponds to a memory segment.
- a plurality of memory segments correspond to a memory block 701 A-N and are associated with a single counter 702 A-N.
- a portion of a segment corresponds to a memory block 701 A-N and is associated with a single counter 702 A-N.
- each counter of counters 702 A-N is statically associated with each memory block 701 A-N.
- a counter 702 A-N is assigned to a memory block by counter assignment logic 705 .
- data fetch width indicators are associated with segments translated by the SLB.
- data fetch width indicators are associated with segments translated by the SLB.
- a portion of a memory segment constitutes a memory block
- multiple data fetch width indicators are associated with segments translated by the SLB.
- data fetch width indicators are associated with memory pages.
- data fetch width indicators are stored in one of a TLB, an effective to real address table (ERAT), a page table, a separate data fetch width cache, and key storage.
- cache memory 700 corresponds to ERAT and stores effective to real (or physical) memory addresses translations.
- each memory block 701 A-N corresponds to a memory page translated by the ERAT.
- a plurality of memory pages translated by the ERAT correspond to a memory block 701 A-N and are associated with a single counter of counters 702 A-N.
- each counter of counters 702 A-N is statically associated with each memory block 701 A-N.
- a counter 702 A-N is assigned to a memory block by counter assignment logic 705 .
- data fetch width indicators are associated with pages translated by the ERAT.
- data fetch width indicators are associated with pages translated by the ERAT.
- data fetch width indicators are associated with memory blocks consisting of multiple pages translated by the ERAT.
- an associated counter of counters 702 A-N is deallocated for the associated memory block.
- a value of deallocated associated counter 702 A-N is stored in storage.
- the value is stored in another cache structure, e.g., when an ERAT address translation is deallocated, a counter may be stored in a corresponding TLB entry.
- the counter value is stored in cache memory 200 , e.g., optionally in a transient cache storage with discard function for disposable data
- storage of the counter value is in main memory 103 .
- storage of the counter value is performed automatically by hardware.
- a notification step is performed to supervisory software 108 and the counter value is stored by supervisory software 108 .
- the counter is allocated to a new memory block.
- the counter is initialized to 0.
- the stored counter value is retrieved and used to initialize the newly allocated counter.
- FIG. 8 illustrates an embodiment of a method for counter-based wide fetch management.
- FIG. 8 is discussed with respect to FIGS. 1-7 .
- an application such as application 105 A
- starts execution by processor 101 and at least one memory page such as memory page(s) 106 A are allocated in main memory 103 for the application 105 A.
- An initial data fetch width indicator which may correspond to a narrow cache line size, is set for the allocated memory page(s) 106 A.
- the data fetch width indicator may be set in a page table entry associated with the memory page(s) 106 A in some embodiments, or in memory-area property storage in the memory page(s) 106 (A) in main memory 103 in other embodiments.
- a counter which may be one of counters 601 A-N shown in FIG. 6 , or counters 702 A-N as shown in FIG. 7 , is assigned and initialized for a memory region that is allocated to application 105 A by counter management module 109 .
- the memory region may comprise one or more of memory page(s) 106 A in some embodiments or a portion of a memory page of memory page(s) 106 A in other embodiments.
- Multiple counters may be assigned to a single application such as application 105 A; each counter corresponds to a single memory region.
- cache lines such as cache lines 202 A-N
- cache lines 202 A-N are installed in the cache memory 102 from memory page(s) 106 A.
- the cache line's associated use indicator 203 A-N is set to untouched.
- the processor 101 touches the line during execution of the application 105 A the associated use indicator 203 A-N is set to touched.
- a use indicator 203 A-N may be updated to indicate that the use indicator's respective cache line was touched based one or more of a read access of the cache line, a write access of the cache line, and zeroing of the cache line by a dcbz instruction, which comprises instruction that fills a fixed-size chunk of memory with zeroes.
- the dcbz instruction may correspond to a fraction of a cache line in one embodiment, or correspond to an entire cache line in another embodiment.
- a line such as cache line 202 A, that is associated with a memory region of memory page(s) 106 A is evicted from the cache 200 , and it is determined by counter management module 109 whether an adjacent line, such as cache line 202 B, was also touched based on use indicator 203 B.
- Table 1 illustrates a pseudocode example of block 803 for an embodiment where a cache entry can comprise up to 2 cache lines:
- the cache tag comparison for up to j tag matches corresponding to j associative elements in an associativity class are performed in parallel by tag match logic associated to a data port 208 to perform cache hit/miss determination and way selection in conjunction with a data port 208 , or by tag match logic associated to a cache snoop port 207 to perform interference determination based on snooping remote processor data accesses, or protocol requests, in accordance with the operation of snoop port 207 to perform multi-processor coherence actions.
- flow proceeds to block 805 , in which the counter associated with the memory region that is assigned to the counter is incremented by counter management module 109 .
- Flow then proceeds to block 806 , in which it is determined whether the counter that was incremented in block 805 is above a predetermined threshold. In some embodiments of block 806 , it may also be determined whether a predetermined number of fetches have been performed from the memory region; if the predetermined number of fetches have not been performed, it may be determined that the counter is not above the predetermined threshold in block 806 , so as to avoid having a low number of fetches cause an over-threshold condition.
- the hardware notification consists of an exception being raised, with control being transferred to supervisory software 108 .
- Supervisory software 108 may then update the data fetch width indicator of the memory region based on the notification. In one embodiment, when a counter has been assigned to a plurality of pages or regions, a plurality of data fetch width indicators are updated.
- the data fetch width indicator may be updated by the supervisory software 108 in a page table entry associated with the memory region in some embodiments, or in memory-area property storage in the memory region in main memory 103 in other embodiments.
- flow proceeds from block 804 to block 808 , in which the counter associated with the memory region is decremented. Flow then proceeds to block 809 , in which it is determined whether a predetermined amount of time or predetermined number of fetches have elapsed since the particular counter was assigned and initialized in block 801 . If it is determined in block 809 that the predetermined amount of time or predetermined number of fetches have elapsed since the counter was assigned and initialized in block 801 , flow proceeds from block 809 to block 810 , in which the counter associated with the memory region is disabled; the counter may be reassigned for use by another memory region by counter management module 109 .
- a computer program product 900 includes, for instance, one or more storage media 902 , wherein the media may be tangible and/or non-transitory, to store computer readable program code means or logic 904 thereon to provide and facilitate one or more aspects of embodiments described herein.
- the present invention may be a system, a method, and/or a computer program product.
- the computer program product may include a computer readable storage medium (or media) having computer readable program instructions thereon for causing a processor to carry out aspects of the present invention.
- the computer readable storage medium can be a tangible device that can retain and store instructions for use by an instruction execution device.
- the computer readable storage medium may be, for example, but is 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 the computer readable storage medium includes the following: a portable computer diskette, a hard disk, a random access memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or Flash memory), a static random access memory (SRAM), a portable compact disc read-only memory (CD-ROM), a digital versatile disk (DVD), a memory stick, a floppy disk, a mechanically encoded device such as punch-cards or raised structures in a groove having instructions recorded thereon, and any suitable combination of the foregoing.
- RAM random access memory
- ROM read-only memory
- EPROM or Flash memory erasable programmable read-only memory
- SRAM static random access memory
- CD-ROM compact disc read-only memory
- DVD digital versatile disk
- memory stick a floppy disk
- a mechanically encoded device such as punch-cards or raised structures in a groove having instructions recorded thereon
- a computer readable storage medium is not to 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 media (e.g., light pulses passing through a fiber-optic cable), or electrical signals transmitted through a wire.
- Computer readable program instructions described herein can be downloaded to respective computing/processing devices from a computer readable storage medium or to an external computer or external storage device via a network, for example, the Internet, a local area network, a wide area network and/or a wireless network.
- the network may comprise copper transmission cables, optical transmission fibers, wireless transmission, routers, firewalls, switches, gateway computers and/or edge servers.
- a network adapter card or network interface in each computing/processing device receives computer readable program instructions from the network and forwards the computer readable program instructions for storage in a computer readable storage medium within the respective computing/processing device.
- Computer readable program instructions for carrying out operations of the present invention may be assembler instructions, instruction-set-architecture (ISA) instructions, machine instructions, machine dependent instructions, microcode, firmware instructions, state-setting data, or either source code or object code written in any combination of one or more programming languages, including an object oriented programming language such as Smalltalk, C++ or the like, and conventional 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, partly on the user's computer, as a stand-alone software package, partly on the user's computer and partly on a remote computer or entirely on the remote computer or server.
- 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 the connection may be made to an external computer (for example, through the Internet using an Internet Service Provider).
- electronic circuitry including, for example, programmable logic circuitry, field-programmable gate arrays (FPGA), or programmable logic arrays (PLA) may execute the computer readable program instructions by utilizing state information of the computer readable program instructions to personalize the electronic circuitry, in order to perform aspects of the present invention
- These computer readable program instructions may be provided to a processor of a general purpose computer, special purpose computer, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, create means for implementing the functions/acts specified in the flowchart and/or block diagram block or blocks.
- These computer readable program instructions may also be stored in a computer readable storage medium that can direct a computer, a programmable data processing apparatus, and/or other devices to function in a particular manner, such that the computer readable storage medium having instructions stored therein comprises an article of manufacture including instructions which implement aspects of the function/act specified in the flowchart and/or block diagram block or blocks.
- the computer readable program instructions may also be loaded onto a computer, other programmable data processing apparatus, or other device to cause a series of operational steps to be performed on the computer, other programmable apparatus or other device to produce a computer implemented process, such that the instructions which execute on the computer, other programmable apparatus, or other device implement the functions/acts specified in the flowchart and/or block diagram block or blocks.
- each block in the flowchart or block diagrams may represent a module, segment, or portion of instructions, which comprises one or more executable instructions for implementing the specified logical function(s).
- the functions noted in the block may occur out of the order noted in the figures.
- two blocks shown in succession may, in fact, be executed substantially concurrently, or the blocks may sometimes be executed in the reverse order, depending upon the functionality involved.
Landscapes
- Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Human Computer Interaction (AREA)
- Memory System Of A Hierarchy Structure (AREA)
Abstract
Description
- The present invention relates generally to computer systems, and more specifically, to a page table including a data fetch width indicator in a computer system.
- In the field of computing, a cache is a small, fast memory or storage device used to store data or instructions that were accessed recently, are accessed frequently, or are likely to be accessed in the future, by a processor. Reading from or writing to a cache is typically cheaper (in terms of access time and/or resource utilization) than accessing other memory or storage devices in a computer system. Once data is fetched from main memory and stored in the cache, the data can be accessed in the cache instead of re-fetching the data from main memory, saving both time and resources. A cache is made up of units of storage referred to as cache lines having a cache line size, and each cache line has an associated cache tag that references the cache line. Data may be fetched from the main memory in units equal to the cache line size for installation in the cache.
- Embodiments include a method, system, and computer program product for a page table including a data fetch width indicator. An aspect includes allocating a memory page in a main memory of a computer to an application that is executed by a processor of the computer. Another aspect includes creating a page table entry corresponding to the memory page in the page table. Another aspect includes determining, by a data fetch width indicator determination logic, the data fetch width indicator for the memory page. Another aspect includes sending a notification of the determined data fetch width indicator from the data fetch width indicator determination logic to supervisory software. Another aspect includes setting the data fetch width indicator in the page table entry by the supervisory software based on the notification. Another aspect includes, based on a cache miss in a cache memory of the computer corresponding to an address that is located in the memory page, determining the data fetch width indicator in the page table entry associated with the memory page in the page table, and fetching an amount of data from the memory page based on the data fetch width indicator.
- The subject matter which is regarded as embodiments is particularly pointed out and distinctly claimed in the claims at the conclusion of the specification. The forgoing and other features, and advantages of the embodiments are apparent from the following detailed description taken in conjunction with the accompanying drawings in which:
-
FIG. 1 depicts a computer system with a page table including a data fetch width indicator in accordance with an embodiment; -
FIG. 2 depicts a cache memory for use with a page table including a data fetch width indicator in accordance with an embodiment; -
FIG. 3 depicts a process flow for memory page allocation using a page table including a data fetch width indicator in accordance with an embodiment; -
FIG. 4 depicts a process flow for a data fetch using a page table including a data fetch width indicator in accordance with an embodiment; -
FIG. 5 depicts a page table entry including a data fetch width indicator in accordance with an embodiment; -
FIG. 6 depicts a counter management module for counter-based wide fetch management in accordance with an embodiment; -
FIG. 7 depicts a cache memory and counter management module for counter-based wide fetch management in accordance with an embodiment; -
FIG. 8 depicts a process flow counter-based wide fetch management in accordance with an embodiment; and -
FIG. 9 illustrates a computer program product in accordance with an embodiment. - Embodiments of page table including a data fetch width indicator are provided, with exemplary embodiments being discussed below in detail. Some applications that are executed by a computer system may require a relatively large amount of adjacent data, and benefit from wider (larger) cache lines, while other applications may benefit from narrower (smaller) cache lines, which have more associativity and more index bits (e.g., cache tags). Therefore, a cache may be designed to have a relatively narrow cache line length (for example, 32 bytes or 64 bytes in some embodiments), and fetches to populate cache entries in the cache may correspond to one cache line, or may correspond to multiple cache lines, as needed by the application associated with the cache entry. The size of a cache entry is determined based on a data fetch width indicator that is stored in the page table entry for the memory page in the main memory from which the data in the cache entry was fetched. The data fetch width indicator may be set in each page table entry when a memory page is allocated for use by an application, and the corresponding page table entry is created in the page table. The data fetch width indicator may comprise, in various embodiments, a wide fetch indicator (WFI) that indicates whether wide fetching is enabled for the memory page, and/or a wide fetch factor indicator (WFFI) that indicates a number of cache lines to fetch simultaneously in a data fetch.
- The data fetch width indicator in each page table entry may be set by software in some embodiments, based on, for example, a parameter in an MMAP system call; a parameter associated with an application, a library, or other code module; a software algorithm implemented by an application, a program loader, a dynamic optimization module, or supervisory software such as an operating system or a hypervisor. In other embodiments, the data fetch width indicator in each page table entry is set by hardware based on, for example, a hardware mechanism that identifies whether wide or narrow data fetches are appropriate for a particular memory page. In further embodiments, a hardware mechanism determines the data fetch width indicator, and sends a notification to the supervisory software to set the data fetch width indicator based on the determination.
- In some embodiments, the data fetch width indicator may be set in the page table entry based on a type of the application for which the memory page is allocated. For example, database or high performance computing (HPC) workloads may have a relatively wide data fetch width indicator (e.g., 2 to 4 cache lines per data fetch), while other workloads, such as scripting languages (e.g., for domain-specific languages, or DSLs), may have a relatively narrow data fetch width indicator (e.g., a single cache line per data fetch). In other embodiments, the data fetch width indicator may be initialized to a default value. In further embodiments, the behavior of the application associated with a page table entry may be monitored during execution, and the data fetch width indicator in the page table entry may be updated based on the monitoring. The monitoring may maintain a counter of a number of times the application has accessed adjacent cache lines, and, based on the counter reaching a threshold, increase the data fetch width indicator in the page table entry associated with the application. In some embodiments, multiple page table entries in a page table may point to a single physical memory page; in such embodiments, multiple page table entries that point to the same memory page are simultaneously updated when the threshold is reached for the memory page. In another embodiment, multiple page table entries that point to the same memory page are separately updated when references to the page via a specific page table entry reach the threshold, reflecting possibly different application access patterns via different page table entries.
- The monitoring of application behavior and updating of the data fetch width indicator may be performed in conjunction with a runtime system that is executing the application, such as a just-in-time (JIT) compiler, a dynamic system optimizer, or a dynamic compiler. This may avoid direct manipulation of page table entries. For example, in a system using a Linux™ operating system in conjunction with PowerVM™, two distinct sets of page table structures are maintained, a first set by PowerVM and a second set by Linux. In such a system, when hardware indicates a page table entry fault, Linux installs a copy of its private radix page table entry in the PowerVM hardware page table. In some embodiments, Linux then synchronizes the PowerVM page table with the software page table after a data fetch width indicator in the software page table has been updated based on reaching the threshold. Thus, in some environments, the operating system may track the data fetch width indicators separately from the hardware translation implementation. The hardware page tables are managed as a cache, and are not copied back into the operating system page tables. Therefore, direct updates to the hardware page tables will be lost in the course of hardware page table entry replacement. Allowing an update to a data fetch width indicator to be processed by privileged supervisory software gives the software stack the ability to reflect the update in the operating system page table entries.
- The monitoring may be implemented in a hardware module comprising a counter management module that determines updated data fetch width indicators based on identification of whether wide or narrow data fetches are appropriate for a particular memory region, which may comprise one or more memory pages in some embodiments, or a portion of a memory page in other embodiments. In some embodiments, single-bit use indicators are provided in each cache line in the cache memory, and the counter management module maintains a count of how often adjacent cache lines were touched based on the use indicators. If the counter for a memory region exceeds a threshold, the data fetch width indicator of the memory region is updated to allow wide fetches, or to increase the fetch size. In further embodiments, the counter for memory region may be disabled based on one of: enabling of wide fetch for the memory region, elapsing of a predetermined time period since assigning the counter to the memory region, and performing a predetermined number of fetches to the cache memory from the memory region. A disabled counter may be reused by a different memory region. In further embodiments, the counter management module determines a value for a data fetch width indicator for a memory region, and sends a hardware notification to supervisory software of the computer system, and the supervisory software sets the data fetch width indicator for the memory region based on the notification.
- In various embodiments, a use indicator may be updated to indicate that a cache line was touched based one or more of a read access of the cache line, a write access of the cache line, and zeroing of the cache line by a dcbz instruction, which comprises instruction that fills a fixed-size chunk of memory with zeroes. The dcbz instruction may correspond to a fraction of a cache line in one embodiment, or correspond to an entire cache line in another embodiment.
- In further embodiments, the cache memory is divided into blocks of N bytes, and a counter is maintained for each block in each level of cache. For example, in a processor with 3 levels of cache, there are 3 counters for each block. A counter(A,L) is a counter associated with a block at address A and cache level L. The cache memory is further organized as S sets of E elements each, and the elements are each cache lines having a cache line size (for example, 64 bytes). In this example, if two of those 64-byte cache lines from a contiguous 128 bytes in a memory page are fetched into the cache memory, the two cache lines are located in consecutive sets. In such an embodiment, the counters may be managed as follows: when there is a miss for an element at address A at cache level L, then, if counter(A,L)>=Threshold, wide fetch for the memory page in which the element is located is enabled; further, when an element at address A is evicted from the cache level L, if both 64-byte elements of a contiguous 128 bytes were touched (e.g., accessed for read-access, accessed for write access, and in at least one embodiment, zeroed by a dcbz instruction corresponding to a fraction of a cache line in one embodiment, and optionally corresponding to an entire cache line in another embodiment) in the cache (determined based on the use indicators), counter(A,L) is incremented; otherwise, counter(A,L) is decremented. In further embodiments, there may not be one counter per level of cache, rather, there may be one counter that is associated with one level of the cache.
- Turning now to
FIG. 1 , acomputer system 100 is generally shown.Computer system 100 includes aprocessor 101 and amain memory 103.Processor 101 includes acache memory 102 that is used for local storage withinprocessor 101.Processor 101 executes a plurality ofapplications 105A-N, which are located inmain memory 103. Each ofapplications 105A-N has at least one respective allocated memory page(s) 106A-N that is used to store data corresponding to theapplication 105A-N (e.g., memory page(s) 106A are allocated toapplication 105A, etc.). Page table 104 is used for address translations from one of the effective or virtual addresses that are used byprocessor 101 during execution ofapplications 105A-N to real addresses in themain memory 103. Each ofmemory pages 106A-N has a respective page table entry in page table 104. Each page table entry in page table 104 includes a data fetch width indicator that indicates a width for data fetches from the memory page, such as allocatedmemory pages 106A-N, that is associated with the page table entry. The data fetch width indicator in each page table entry may vary based on the type of theapplication 105A-N that is associated with the memory page(s) 106A-N that is described by the page table entry.Computer system 100 further comprises a data fetch widthindicator determination logic 107, which comprises a hardware mechanism for adjusting a data fetch width indicator in a page table entry in page table 104, and is discussed below in further detail with respect toFIG. 3 .Supervisory software 108, which may comprise one or more of an operating system and a hypervisor, also runs oncomputer system 100.Computer system 100 further comprises a hardwarecounter management module 109 in communication withcache memory 102, which comprises a hardware mechanism for adjusting data fetch width indicators for memory page(s) 106A-N.FIG. 1 is shown for illustrative purposes only; in various embodiments, a computer system may execute any appropriate number of applications such asapplications 105A-N, and may include any appropriate number of levels of cache memory. -
FIG. 2 illustrates an embodiment of acache memory 200.Cache memory 200 may comprisecache memory 102 ofFIG. 1 .Cache memory 200 includes a plurality ofcache lines 202A-N, each referenced by a respective cache tag 201A-N. Cache entries, such as cache entries 203-205, may comprise one or more ofcache lines 202A-N. The number of cache lines in a cache entry such as cache entries 202-205 is determined based on the data fetch width indicator that is stored in the page table entry associated with the memory page from which the data in the cache entry was fetched. Each of example cache entries 202-205 is associated with a memory page in the main memory that has a different respective data fetch width indicator in its page table entry. - In one embodiment, when a data access is made, an access to a first portion of a cache entry 203 corresponding to
cache line 202A is performed in conjunction with a tag match ofcache tag 201A; an access to a second portion of a cache entry 203 corresponding tocache line 202C is performed in conjunction with a tag match ofcache tag 201C; an access to a first portion of acache entry 204 corresponding tocache line 202B is performed in conjunction with a tag match ofcache tag 201B; an access to a second portion of acache entry 204 corresponding tocache line 202D is performed in conjunction with a tag match ofcache tag 201D; an access to a third portion of acache entry 204 corresponding tocache line 202F is performed in conjunction with a tag match ofcache tag 201F; an access to a fourth portion of acache entry 204 corresponding tocache line 202H is performed in conjunction with a tag match ofcache tag 201H. Thus, a hit and miss indication can be separately determined for each cache line that is part of a single cache entry. In at least one such embodiment, not all cache line constituents of a single cache entry are located in the same associativity class in thecache memory 200. For example, in accordance with an embodiment, a cache entry may comprisecache line 202A with associatedcache tag 201A, andcache line 202D with associatedcache tag 201D. - In another embodiment, a single cache tag is used for an entire entry. In accordance with such embodiments,
cache lines cache tag 201A; cache lines 202B, 202D, 202F, and 202H incache entry 204 are referenced bycache tag 201B; andcache line 202E incache entry 205 is referenced bycache tag 201E. In some embodiments, all cache lines of a single cache entry are placed in the same associativity class in thecache memory 200. In conjunction with a cache size entry indicator associated with each cache entry, cache tag matching may be performed using a single cache tag for all the cache lines that make up a cache entry. - Cache lines 202A-N may have any appropriate size in various embodiments. For example, each of
cache lines 202A-N may be 32 bytes in some embodiments; in such embodiments, cache entry 203 is 64 bytes,cache entry 204 is 128 bytes, andcache entry 205 is 32 bytes. In another example, each ofcache lines 202A-N may be 64 bytes in some embodiments; in such embodiments, cache entry 203 is 128 bytes,cache entry 204 is 256 bytes, andcache entry 205 is 64 bytes.FIG. 2 is shown for illustrative purposes only; a cache memory may have any appropriate number of cache lines and cache entries, and the cache entries may each span any appropriate number of cache lines. - Each
cache line 202A-N includes a respective use indicator 203A-N comprising a 1-bit field that indicates whether the cache line has been touched by theprocessor 101. When a cache line is installed incache memory 200, the associated use indicator is set to untouched (for example, 0); when the cache line is touched by theprocessor 101, the associated use indicator is set to touched (for example, 1). Thecache memory 200 also includes aseparate data port 208 that is used to install data in thecache memory 200 and to access data in thecache memory 200 byprocessor 101 in conjunction with tag match logic (not shown) to determine hits and misses in thecache memory 200. In some embodiments, thecache memory 200 further includes a snoopport 207, which may be used by a tag match logic (not shown) of the computer system to determine hits and misses in thecache memory 200 in order to determine whether remote processor data requests from memory refer to data currently resident incache memory 200. In accordance with one embodiment, thecounter management module 109 that was shown inFIG. 1 operates in conjunction withdata port 208. In accordance with another embodiment, thecounter management module 109 that was shown inFIG. 1 operates in conjunction with snoopport 207 such that the operations of thecounter management module 109 do not conflict with data operations concurrently being performed viadata port 208.FIG. 2 is shown for illustrative purposes only; a cache memory may have any appropriate number of cache lines and cache entries, and the cache entries may each span any appropriate number of cache lines. Further, in some embodiments, the cache memory includes an additional port that is distinct from the snoop and data port and that is used by thecounter management module 109. - In various embodiments, a use indicator of use indicators 203A-N may be updated to indicate that its respective cache line was touched based one or more of a read access of the cache line, a write access of the cache line, and zeroing of the cache line by a dcbz instruction, which comprises instruction that fills a fixed-size chunk of memory with zeroes. The dcbz instruction may correspond to a fraction of a cache line in one embodiment, or correspond to an entire cache line in another embodiment.
-
FIG. 3 illustrates an embodiment of amethod 300 for memory page allocation using a page table including a data fetch width indicator.FIG. 3 is discussed with reference toFIGS. 1 and 2 . First, inblock 301, an application, such asapplication 105A, is executed byprocessor 101, and at least one memory page such as memory page(s) 106A are allocated inmain memory 103 for theapplication 105A. Next, inblock 302, an initial page table entry including a data fetch width indicator is created in page table 104 for the allocated memory page(s) 106A. In some embodiments, the data fetch width indicator may be set inblock 302 based on the type ofapplication 105A. The data fetch width indicator may be set inblock 302 by software in some embodiments, based on, for example, a parameter in an MMAP system call, a parameter associated with an application, a library, or other code module; a software algorithm implemented by an application, a program loader, a dynamic optimization module, an operating system, or a hypervisor. In other embodiments, the data fetch width indicator may be set inblock 302 to a preferred initial size, such as a maximum cache line size, prior to performing a hardware method for optimizing the cache line size. - Next, in
block 303, after an initial data fetch width indicator has been set in the page table entry for the memory page(s) 106A, a hardware module comprising a data fetch widthindicator determination logic 107 is invoked in the hardware ofcomputer system 100. The data fetch widthindicator determination logic 107 is a hardware mechanism that identifies whether wide or narrow data fetches are appropriate for the particular memory page(s) 106A. In some embodiments, data fetch widthindicator determination logic 107 is invoked with a special instruction. In other embodiments, the data fetch widthindicator determination logic 107 invoked based on writing to, for example, a control register incomputer system 100. In some embodiments, the writing to the control register provides additional configuration information for use in determining the data fetch width indicator, for example, a threshold for determining a preferred line size, e.g., a number of accesses to be performed before a determination of the data fetch width indicator is made. In further embodiments, the data fetch widthindicator determination logic 107 is invoked based on an initial load of the page table entry into a memory management unit (MMU) translation structure, such as an effective to read address translation (ERAT) or a translation lookaside buffer (TLB). Invoking the data fetch widthindicator determination logic 107 causes the data fetch widthindicator determination logic 107 to determine an updated data fetch width indicator responsive to workload behavior ofapplication 105A and current overall system behavior ofcomputer system 100 inblock 303. - Next, in
block 304, a hardware notification is received indicating that an updated data fetch width indicator has been determined for memory page(s) 106A. The notification comprises a hardware exception to that is received bysupervisory software 108 from the data fetch widthindicator determination logic 107. In some embodiments, thesupervisory software 108 comprises an operating system or a hypervisor. - Then, in
block 305, based on receiving the notification ofblock 304 by thesupervisory software 108, the updated data fetch width indicator is set in the page table entry for memory page(s) 106A in page table 104. In some embodiments, upon receiving the notification, thesupervisory software 108 determines which page table entry in page table 104 corresponds to the notification, and the updated data fetch width indicator is set in the page table entry that corresponds to the notification. In one such embodiment, when thesupervisory software 108 updates the page table entry, an invalidation operation is performed to force a subsequent reloading of a page table entry with the updated data fetch width indicator to a translation structure such as an ERAT or TLB. In some embodiments, two distinct page table representations are present, e.g., a first software page table structured as a radix page table, and a second hardware page table, or hashed page table (HPT), that is maintained as a hashed cache of recently used page translations that is managed by hardware. In some embodiments, the software page table is directly maintained by the operating system, and the HPT is maintained jointly by an operating system and a hypervisor. In some embodiments, when a notification is delivered from hardware to the operating system, the software page table is then updated with the hardware-determined data fetch width indicator. A hypervisor call is then performed to update a cached value for a data fetch width indicator in the HPT. In further embodiments, data fetch widthindicator determination logic 107 incomputer system 100 may directly update at least one page table entry in addition to sending the notification, in order to reduce the overhead associated with performing the processing of a notification event. In further embodiments, data fetch widthindicator determination logic 107 may directly update the data fetch width indicator in at least one translation structure entry (such as an ERAT or TLB entry) in addition to performing a page table update to reduce the overhead associated with synchronizing a data fetch width indicator contained in a translation entry with a page table entry. - In further embodiments, when the notification is delivered directly to the hypervisor, the hypervisor may update the HPT, and further optionally send a notification to the operating system to update a software page table. No synchronization is necessary from the OS to the hypervisor to update the HPT in such an embodiment. In further embodiments, the data fetch width
indicator determination logic 107 is configurable, such that the data fetch widthindicator determination logic 107 may perform one or both of sending a notification to thesupervisory software 108, and directly updating at least one of a page table entry and an address translation structure entry (e.g., reflective of a system using two levels of page tables corresponding to software and hardware page tables and utilizing notifications, and a system using a single level of hardware page tables). In further embodiments, the notification is sent in conjunction with additional algorithms in software, for example, a JIT, a dynamic system optimizer, or dynamic re-compiler to further determine a final data fetch width indicator for a page such as memory page(s) 106A, giving software additional control over system performance. In some embodiments, multiple page table entries may point to a single physical page inmain memory 103, making it desirable to simultaneously update multiple PTEs when a notification is received. - Lastly, in
block 306, during execution ofapplication 105A, the execution of theapplication 105A is monitored, and the data fetch width indicator in the page table entry corresponding toapplication 105A may be updated based on the monitoring by repeating blocks 303-305. The monitoring ofblock 306 occurs in conjunction with invoking of the data fetch widthindicator determination logic 107 as described with respect to block 303, either immediately after the initial determination of the data fetch width indicator, or periodically based on either changes in system workloads and configuration, or after a fixed period of time has lapsed. System configuration events that may trigger monitoring may include changes in the number or nature of workloads simultaneously executed bycomputer system 100, or changes in system behavior (e.g., cache miss rates, instructions per cycle (IPC), cycles per instruction (CPI), or other such performance indicators) being observed by hardware or a program optimization component. The monitoring may comprise maintaining a counter of a number of times theapplication 105A accesses adjacent cache lines, and comparing the counter to a threshold to determine whether the data fetch width indicator in the page table entry corresponding to the application needs to be modified. -
FIG. 4 illustrates an embodiment of amethod 400 for a data fetch using a page table including a data fetch width indicator.FIG. 4 is discussed with reference toFIGS. 1 and 2 . First, inblock 401, there is a cache miss incache memory 102 during execution of an application, such asapplication 105A, byprocessor 101. Next, inblock 402,processor 101 uses page table 104 to translate one of the effective or virtual address of the cache miss to a real address in memory page(s) 106A inmain memory 103, and also determines the data fetch width indicator of the memory page where the real address associated with the cache miss is located. The data fetch width indicator is located in the memory page's associated page table entry in page table 104. Inblock 403, theprocessor 101 fetches the data associated with the cache miss from the location in the memory page(s) 106A that is specified by the real address. The amount of data that is fetched corresponds to the data fetch width indicator that was determined inblock 403. In some embodiments ofblock 403 ofmethod 400, the fetched data comprises a set of cache lines starting at a multiple of the fetch width, i.e., if the cache line size is 32 bytes and the fetch width is 4 cache lines, then the following fetches are executed: -
- for I=0 . . . 3
- fetch((start_address & MASK)+I*32)
- for I=0 . . . 3
- In some embodiments, the mask corresponds to a mask to mask out bits corresponding to a line index within an entry. In the above example, the cache line size is 32 bytes and the fetch width is 128 bytes (4 cache lines), then the MASK value would be 0xFFFFFF80 (binary 0b11111111111111111111111110000000), if the address is expressed as a 32-bit byte address. More generally, in at least one embodiment, the mask corresponds to (WFFI*CLS), i.e., the two's complement of the wide fetch factor indicator (WFFI) in the page table, or specified elsewhere (e.g., in a boot parameter, SPR, during design time, and so forth), multiplied by the cache line size (CLS). Thus, more generally, the fetch might be expressed as:
-
- for I=0 . . . WFFI−1
- fetch((start_address &(−WFFI*CLS))+I*CLS)
if the fetch address is a byte address. In other embodiments ofblock 403 ofmethod 400, a set of cache lines starting at the requested line is fetched, i.e.,
- fetch((start_address &(−WFFI*CLS))+I*CLS)
- for I=0 . . . 3
- fetch(start_address+I*32)
More generally, this may be expressed in terms of the number of cache lines in an entry as:
- fetch(start_address+I*32)
- for I=0 . . . WFFI−1
- fetch(start_address+I*CLS)
if the fetch address is a byte address. Lastly, inblock 404, the fetched data is corresponding to the cache miss is installed in the cache as a cache entry. The cache entry may comprise one or more lines in the cache memory, as specified by the data fetch width indicator that was determined inblock 402.
- fetch(start_address+I*CLS)
- for I=0 . . . WFFI−1
-
FIG. 5 depicts an embodiment of apage table entry 500 including a data fetch width indicator.Page table entry 500 may be stored in page table 104 ofFIG. 1 .Page table entry 500 ofFIG. 5 is a 32-bit entry comprising a plurality of fields 501-512. The data fetch width indicator inpage table entry 500 comprises wide fetch factor indicator (WFFI) 502, which is stored in bit 11 and bit 10, and wide fetch indicator (WFI) 503, which is stored inbit 9. TheWFFI 502 indicates how many lines should concurrently be fetched from the memory page associated withpage table entry 500, and theWFI 503 indicates whether wide fetch is enabled for the memory page associated withpage table entry 500. Bit 31 through bit 12 comprise a page frame address (PFA) 501.Bit 8 comprises a zerofield 504.Bit 7 comprises anL field 505.Bit 6 comprises adirty indicator field 506.Bit 5 comprises an accessedindicator field 507.Bit 4 comprises a page cachedisabled indicator field 508.Bit 3 comprises a page writetransparent indicator field 509.Bit 2 comprises a useraccessible indicator field 510. Bit 1 comprises awriteable indicator field 511.Bit 0 comprises apresent indicator field 512.Page table entry 500 is shown for illustrative purposes only; for example, in some embodiments,WFI 503 may be omitted, and a 3-bit WFFI 502 may be provided.FIG. 5 is shown for illustrative purposes only, a page table entry may have any appropriate number of bits and any appropriate number and type of fields. In some embodiments, the WFFI and WFI are represented by a single field, and one particular WFFI value may indicate no wide fetch. - While the storage of
WFFI 502 andWFI 503 are discussed above in conjunction with storage in page table entries, in another embodiment, theWFFI 502 andWFI 503 are stored in a segment tables in conjunction with segment table entries. In accordance with one embodiment,WFFI 502 andWFI 503 are stored in the segment lookaside buffer entries (SLBE) of the segment lookaside buffer (SLB) of the Power ISA. - In some embodiments, one or both of the
WFFI 502 andWFI 503 are stored in a caching structure for page translations in hardware so as to accelerate access to theWFFI 502 andWFI 503. In at least one embodiment, theWFFI 502 andWFI 503 are obtained from one of a page table entry (PTE, optionally cached in a TLB) and a segment lookaside entry (SLBE) of a segment lookaside buffer during the address translation process and stored in the effective to real address table for rapid access in conjunction withblock 402 ofFIG. 4 . - Embodiments of a page table entry including a data fetch width indicator may be implemented in environments based on the PowerPC architecture, also referred to as Power ISA, offered by International Business Machines Corporation (IBM®) and described in the Power ISA™ Version 2.06 Revision B specification, Jul. 23, 2010, hereby incorporated by reference herein in its entirety, and may include one or more aspects, as well as computing environments of other architectures, such as the z/Architecture, offered by International Business Machines Corporation, and described in z/Architecture—Principles of Operation, Publication No. SA22-7932-09, 10th Edition, September 2012, which is hereby incorporated by reference herein in its entirety.
-
FIG. 6 illustrates an embodiment of acounter management module 600.Counter management module 600 may comprisecounter management module 109 ofFIG. 1 .Counter management module 600 includes a plurality ofcounters 601A-N, and a counter assignment and enable/disablelogic 602. Thecounter management module 600 further includes an interface 603 to a snoop port of a cache memory such ascache memory 102/200, or to another port tocache memory 200. Counter assignment and enable/disablelogic 602 assigns counters ofcounters 601A-N to memory regions ofmemory pages 106A-N that are allocated to applications such asapplications 105A-N, and increments and decrements thecounters 601A-N as needed based on accesses of adjacent lines in the cache memory. Counter assignment and enable/disablelogic 602 further determines if a counter ofcounters 601A-N is above a predetermined threshold, and, based on determining that a counter ofcounters 601A-N is above the predetermined threshold, causes a hardware notification to be sent to thesupervisory software 108 so thatsupervisory software 108 may update the data fetch width indicator of memory region of memory page(s) 106A-N that is associated with the counter. Counter assignment and enable/disablelogic 602 further determines if a predetermined time period or a predetermined number of fetches have elapsed since the assignment of a counter ofcounters 601A-N, and if the predetermined time period or the predetermined number of fetches have elapsed, disables the counter. A disabled counter may be reassigned to a subsequent memory region of an application.FIG. 6 is shown for illustrative purposes only; a counter management module may include any appropriate number of counters, and may, in some embodiments, be connected to an additional port of the cache memory that is distinct from both the snoop port and the data port. - In some embodiments of a
counter management module 600, counters 601A-N are stored in a separate counter array. In some embodiments, a counter is associated with a memory block and may optionally be stored in conjunction with a translation structure for translating addresses of memory blocks that are organized as a cache of recent address translations for blocks of memory. -
FIG. 7 illustrates an embodiment of a counter management module 704, in conjunction with acache memory 700. Counter management module 704 may comprisecounter management module 109 ofFIG. 1 , andcache memory 700 may comprise one of a translation lookaside buffer (TLB), a segment lookaside buffer (SLB), and an effective to real address table (ERAT). In the embodiment ofFIG. 7 , thecache memory 700 comprises a plurality of memory blocks 701A-N, and arespective counter 702A-N is maintained in thecache memory 700 for eachmemory block 701A-N. The memory blocks 701A-N may be about 4 kilobytes each in some embodiments. Eachcounter 702A-N may be assigned to addresses in the counter's respective memory block of memory blocks 701A-N. The counters 702A-N are managed by counter assignment and disable/enablelogic 705 in counter management module 704 viaport 703, as described above with respect to countermanagement module 600 ofFIG. 6 .FIG. 7 is shown for illustrative purposes only; a cache memory may comprise any appropriate number of memory blocks of any appropriate size, and each memory block may have any appropriate number of associated counters. - In at least one embodiment,
cache memory 700 corresponds to a cache of address translations. In one embodiment,cache memory 700 comprises a TLB and stores virtual to physical (or real) memory addresses translations. In one such embodiment, eachmemory block 701A-N corresponds to a memory page. In another embodiment, a plurality of memory pages comprise to a single memory block of memory blocks 701A-N and are associated with asingle counter 702A-N. In one embodiment, each counter ofcounters 702A-N is statically associated with arespective memory block 701A-N. In another embodiment, acounter 702A-N is assigned to a memory bock bycounter assignment logic 705. In one embodiment, data fetch width indicators are associated with pages translated by the TLB. In another embodiment, in which a plurality of memory pages comprise a memory block, data fetch width indicators are associated with pages translated by the TLB. In another embodiment, in which a plurality of memory pages comprise a memory block, data fetch width indicators are associated with memory blocks comprising multiple memory pages translated by the TLB. - In further embodiments,
cache memory 700 corresponds to a SLB and stores effective to virtual memory addresses translations. In one embodiment, such segment address translations are performed in accordance with the Power ISA. In one such embodiment, eachmemory block 701A-N corresponds to a memory segment. In another embodiment, a plurality of memory segments correspond to amemory block 701A-N and are associated with asingle counter 702A-N. In another embodiment, a portion of a segment corresponds to amemory block 701A-N and is associated with asingle counter 702A-N. In one embodiment, each counter ofcounters 702A-N is statically associated with eachmemory block 701A-N. In another embodiment, acounter 702A-N is assigned to a memory block bycounter assignment logic 705. In one embodiment, data fetch width indicators are associated with segments translated by the SLB. In another embodiment, in which a plurality of memory segments constitute a memory block, data fetch width indicators are associated with segments translated by the SLB. In another embodiment, in which a portion of a memory segment constitutes a memory block, multiple data fetch width indicators are associated with segments translated by the SLB. In another embodiment, in which one of segments, pluralities of segments, and portions of segments correspond to a memory counters, data fetch width indicators are associated with memory pages. In one such embodiment, data fetch width indicators are stored in one of a TLB, an effective to real address table (ERAT), a page table, a separate data fetch width cache, and key storage. - In further embodiments,
cache memory 700 corresponds to ERAT and stores effective to real (or physical) memory addresses translations. In one such embodiment, eachmemory block 701A-N corresponds to a memory page translated by the ERAT. In another embodiment, a plurality of memory pages translated by the ERAT correspond to amemory block 701A-N and are associated with a single counter ofcounters 702A-N. In one embodiment, each counter ofcounters 702A-N is statically associated with eachmemory block 701A-N. In another embodiment, acounter 702A-N is assigned to a memory block bycounter assignment logic 705. In one embodiment, data fetch width indicators are associated with pages translated by the ERAT. In another embodiment, in which a plurality of memory pages comprise a memory block, data fetch width indicators are associated with pages translated by the ERAT. In another embodiment, in which a plurality of memory pages comprise a memory block, data fetch width indicators are associated with memory blocks consisting of multiple pages translated by the ERAT. - In at least one embodiment, when an address translation for a memory block of memory blocks 701A-N is evicted from
cache memory 700, an associated counter ofcounters 702A-N is deallocated for the associated memory block. In one embodiment, when an address translation is evicted, a value of deallocated associatedcounter 702A-N is stored in storage. In accordance with one embodiment, the value is stored in another cache structure, e.g., when an ERAT address translation is deallocated, a counter may be stored in a corresponding TLB entry. In another embodiment, the counter value is stored incache memory 200, e.g., optionally in a transient cache storage with discard function for disposable data In another embodiment, storage of the counter value is inmain memory 103. In accordance with one embodiment, storage of the counter value is performed automatically by hardware. In another embodiment, a notification step is performed tosupervisory software 108 and the counter value is stored bysupervisory software 108. In at least one embodiment, when acounter 702A-N has been deallocated, the counter is allocated to a new memory block. When the counter is allocated to a new memory block, in one embodiment, the counter is initialized to 0. In another embodiment in which a previous counter value for an associated memory block has been stored, the stored counter value is retrieved and used to initialize the newly allocated counter. -
FIG. 8 illustrates an embodiment of a method for counter-based wide fetch management.FIG. 8 is discussed with respect toFIGS. 1-7 . First, inblock 801, an application, such asapplication 105A, starts execution byprocessor 101, and at least one memory page such as memory page(s) 106A are allocated inmain memory 103 for theapplication 105A. An initial data fetch width indicator, which may correspond to a narrow cache line size, is set for the allocated memory page(s) 106A. The data fetch width indicator may be set in a page table entry associated with the memory page(s) 106A in some embodiments, or in memory-area property storage in the memory page(s) 106(A) inmain memory 103 in other embodiments. Further, inblock 801, a counter, which may be one ofcounters 601A-N shown inFIG. 6 , or counters 702A-N as shown inFIG. 7 , is assigned and initialized for a memory region that is allocated toapplication 105A bycounter management module 109. The memory region may comprise one or more of memory page(s) 106A in some embodiments or a portion of a memory page of memory page(s) 106A in other embodiments. Multiple counters may be assigned to a single application such asapplication 105A; each counter corresponds to a single memory region. - Next, in
block 802, during execution ofapplication 105A, cache lines, such as cache lines 202A-N, are installed in thecache memory 102 from memory page(s) 106A. When a cache line is installed, the cache line's associated use indicator 203A-N is set to untouched. When theprocessor 101 touches the line during execution of theapplication 105A, the associated use indicator 203A-N is set to touched. In various embodiments, a use indicator 203A-N may be updated to indicate that the use indicator's respective cache line was touched based one or more of a read access of the cache line, a write access of the cache line, and zeroing of the cache line by a dcbz instruction, which comprises instruction that fills a fixed-size chunk of memory with zeroes. The dcbz instruction may correspond to a fraction of a cache line in one embodiment, or correspond to an entire cache line in another embodiment. - Next, in
block 803, a line, such ascache line 202A, that is associated with a memory region of memory page(s) 106A is evicted from thecache 200, and it is determined bycounter management module 109 whether an adjacent line, such ascache line 202B, was also touched based onuse indicator 203B. Table 1 illustrates a pseudocode example ofblock 803 for an embodiment where a cache entry can comprise up to 2 cache lines: -
TABLE 1 Pseudocode for determining whether adjacent lines have been touched // assume element[i][set] is to be evicted, having fields element[i][set].tag to store a tag, // element[i][set].valid to store valid bit, // element[i][set].accessed to store whether a cache line has been accessed (touched) //etc. both_halves_touched <= FALSE; for j in element_count if(element[j][set XOR 1].tag == element[i][set].tag) if(element[j][set XOR 1].accessed) both_halves_touched <= TRUE; both_halves_touched <= both_halves_touched AND element[i][set].accessed; - In accordance with the pseudocode example of Table 1, in at least one embodiment, the cache tag comparison for up to j tag matches corresponding to j associative elements in an associativity class are performed in parallel by tag match logic associated to a
data port 208 to perform cache hit/miss determination and way selection in conjunction with adata port 208, or by tag match logic associated to a cache snoopport 207 to perform interference determination based on snooping remote processor data accesses, or protocol requests, in accordance with the operation of snoopport 207 to perform multi-processor coherence actions. - Next, in
block 804, if it was determined that both adjacent lines of a prospective wide cache entry were touched (accessed), flow proceeds to block 805, in which the counter associated with the memory region that is assigned to the counter is incremented bycounter management module 109. Flow then proceeds to block 806, in which it is determined whether the counter that was incremented inblock 805 is above a predetermined threshold. In some embodiments ofblock 806, it may also be determined whether a predetermined number of fetches have been performed from the memory region; if the predetermined number of fetches have not been performed, it may be determined that the counter is not above the predetermined threshold inblock 806, so as to avoid having a low number of fetches cause an over-threshold condition. If it is determined inblock 806 that the counter is above the threshold, flow proceeds to block 807, and wide fetch is enabled for the memory region. This may be performed by sending a hardware notification fromcounter management module 109 tosupervisory software 108. In one embodiment, the hardware notification consists of an exception being raised, with control being transferred tosupervisory software 108.Supervisory software 108 may then update the data fetch width indicator of the memory region based on the notification. In one embodiment, when a counter has been assigned to a plurality of pages or regions, a plurality of data fetch width indicators are updated. The data fetch width indicator may be updated by thesupervisory software 108 in a page table entry associated with the memory region in some embodiments, or in memory-area property storage in the memory region inmain memory 103 in other embodiments. Flow then proceeds from block 807 to 810, in which the counter associated with the memory region is disabled based on wide fetch having been enabled for the memory region; the counter may then be reassigned for use by another memory region bycounter management module 109. If it was determined inblock 806 that the counter is not above the threshold, flow proceeds fromblock 806 to block 809, which is discussed below. - If it was determined in
block 804 that adjacent lines were not touched (accessed), flow proceeds fromblock 804 to block 808, in which the counter associated with the memory region is decremented. Flow then proceeds to block 809, in which it is determined whether a predetermined amount of time or predetermined number of fetches have elapsed since the particular counter was assigned and initialized inblock 801. If it is determined inblock 809 that the predetermined amount of time or predetermined number of fetches have elapsed since the counter was assigned and initialized inblock 801, flow proceeds fromblock 809 to block 810, in which the counter associated with the memory region is disabled; the counter may be reassigned for use by another memory region bycounter management module 109. If it is determined inblock 809 that the predetermined amount of time or predetermined number of fetches have not elapsed since the counter was assigned and initialized inblock 801, flow proceeds fromblock 809 to back to block 802, and execution of theapplication 105A continues. - Technical effects and benefits include tailoring the width of data fetches to the workload for which the data is fetched.
- Referring now to
FIG. 9 , in one example, a computer program product 900 includes, for instance, one ormore storage media 902, wherein the media may be tangible and/or non-transitory, to store computer readable program code means orlogic 904 thereon to provide and facilitate one or more aspects of embodiments described herein. - The terminology used herein is for the purpose of describing particular embodiments only and is not intended to be limiting of the invention. As used herein, the singular forms “a”, “an” and “the” are intended to include the plural forms as well, unless the context clearly indicates otherwise. It will be further understood that the terms “comprises” and/or “comprising,” when used in this specification, 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, element components, and/or groups thereof.
- The corresponding structures, materials, acts, and equivalents of all means or step plus function elements in the claims below are intended to include any structure, material, or act for performing the function in combination with other claimed elements as specifically claimed. The description of the present invention has been presented for purposes of illustration and description, but is not intended to be exhaustive or limited to the invention in the form disclosed. Many modifications and variations will be apparent to those of ordinary skill in the art without departing from the scope and spirit of the invention. The embodiment was chosen and described in order to best explain the principles of the invention and the practical application, and to enable others of ordinary skill in the art to understand the invention for various embodiments with various modifications as are suited to the particular use contemplated.
- The present invention may be a system, a method, and/or a computer program product. The computer program product may include a computer readable storage medium (or media) having computer readable program instructions thereon for causing a processor to carry out aspects of the present invention.
- The computer readable storage medium can be a tangible device that can retain and store instructions for use by an instruction execution device. The computer readable storage medium may be, for example, but is 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 the computer readable storage medium includes the following: a portable computer diskette, a hard disk, a random access memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or Flash memory), a static random access memory (SRAM), a portable compact disc read-only memory (CD-ROM), a digital versatile disk (DVD), a memory stick, a floppy disk, a mechanically encoded device such as punch-cards or raised structures in a groove having instructions recorded thereon, and any suitable combination of the foregoing. A computer readable storage medium, as used herein, is not to 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 media (e.g., light pulses passing through a fiber-optic cable), or electrical signals transmitted through a wire.
- Computer readable program instructions described herein can be downloaded to respective computing/processing devices from a computer readable storage medium or to an external computer or external storage device via a network, for example, the Internet, a local area network, a wide area network and/or a wireless network. The network may comprise copper transmission cables, optical transmission fibers, wireless transmission, routers, firewalls, switches, gateway computers and/or edge servers. A network adapter card or network interface in each computing/processing device receives computer readable program instructions from the network and forwards the computer readable program instructions for storage in a computer readable storage medium within the respective computing/processing device.
- Computer readable program instructions for carrying out operations of the present invention may be assembler instructions, instruction-set-architecture (ISA) instructions, machine instructions, machine dependent instructions, microcode, firmware instructions, state-setting data, or either source code or object code written in any combination of one or more programming languages, including an object oriented programming language such as Smalltalk, C++ or the like, and conventional 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, partly on the user's computer, as a stand-alone software package, partly on the user's computer and partly on a remote computer or entirely on the 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 the connection may be made to an external computer (for example, through the Internet using an Internet Service Provider). In some embodiments, electronic circuitry including, for example, programmable logic circuitry, field-programmable gate arrays (FPGA), or programmable logic arrays (PLA) may execute the computer readable program instructions by utilizing state information of the computer readable program instructions to personalize the electronic circuitry, in order to perform aspects of the present invention
- 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.
- These computer readable program instructions may be provided to a processor of a general purpose computer, special purpose computer, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, create means for implementing the functions/acts specified in the flowchart and/or block diagram block or blocks. These computer readable program instructions may also be stored in a computer readable storage medium that can direct a computer, a programmable data processing apparatus, and/or other devices to function in a particular manner, such that the computer readable storage medium having instructions stored therein comprises an article of manufacture including instructions which implement aspects of the function/act specified in the flowchart and/or block diagram block or blocks.
- The computer readable program instructions may also be loaded onto a computer, other programmable data processing apparatus, or other device to cause a series of operational steps to be performed on the computer, other programmable apparatus or other device to produce a computer implemented process, such that the instructions which execute on the computer, other programmable apparatus, or other device implement the functions/acts specified in the flowchart and/or block diagram block or blocks.
- The flowchart and block diagrams in the Figures illustrate the architecture, functionality, and operation of possible implementations of systems, methods, and computer program products according to various embodiments of the present invention. In this regard, each block in the flowchart or block diagrams may represent a module, segment, or portion of instructions, which comprises one or more executable instructions for implementing the specified logical function(s). In some alternative implementations, the functions noted in the block may occur out of the order noted in the figures. For example, two blocks shown in succession may, in fact, be executed substantially concurrently, or the blocks may sometimes be executed in the reverse order, depending upon the functionality involved. It will also be noted that each block of the block diagrams and/or flowchart illustration, and combinations of blocks in the block diagrams and/or flowchart illustration, can be implemented by special purpose hardware-based systems that perform the specified functions or acts or carry out combinations of special purpose hardware and computer instructions.
- The descriptions of the various embodiments of the present invention have been presented for purposes of illustration, but are not intended to be exhaustive or limited to the embodiments disclosed. Many modifications and variations will be apparent to those of ordinary skill in the art without departing from the scope and spirit of the described embodiments. The terminology used herein was chosen to best explain the principles of the embodiments, the practical application or technical improvement over technologies found in the marketplace, or to enable others of ordinary skill in the art to understand the embodiments disclosed herein.
Claims (9)
Priority Applications (3)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
US14/253,059 US9513805B2 (en) | 2014-04-15 | 2014-04-15 | Page table including data fetch width indicator |
US14/483,550 US9524100B2 (en) | 2014-04-15 | 2014-09-11 | Page table including data fetch width indicator |
US15/383,306 US9910781B2 (en) | 2014-04-15 | 2016-12-19 | Page table including data fetch width indicator |
Applications Claiming Priority (1)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
US14/253,059 US9513805B2 (en) | 2014-04-15 | 2014-04-15 | Page table including data fetch width indicator |
Related Child Applications (1)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
US14/483,550 Continuation US9524100B2 (en) | 2014-04-15 | 2014-09-11 | Page table including data fetch width indicator |
Publications (2)
Publication Number | Publication Date |
---|---|
US20150293703A1 true US20150293703A1 (en) | 2015-10-15 |
US9513805B2 US9513805B2 (en) | 2016-12-06 |
Family
ID=54265110
Family Applications (3)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
US14/253,059 Expired - Fee Related US9513805B2 (en) | 2014-04-15 | 2014-04-15 | Page table including data fetch width indicator |
US14/483,550 Expired - Fee Related US9524100B2 (en) | 2014-04-15 | 2014-09-11 | Page table including data fetch width indicator |
US15/383,306 Active US9910781B2 (en) | 2014-04-15 | 2016-12-19 | Page table including data fetch width indicator |
Family Applications After (2)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
US14/483,550 Expired - Fee Related US9524100B2 (en) | 2014-04-15 | 2014-09-11 | Page table including data fetch width indicator |
US15/383,306 Active US9910781B2 (en) | 2014-04-15 | 2016-12-19 | Page table including data fetch width indicator |
Country Status (1)
Country | Link |
---|---|
US (3) | US9513805B2 (en) |
Cited By (1)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
CN111367846A (en) * | 2018-12-25 | 2020-07-03 | 瑞昱半导体股份有限公司 | Data bit width converter and system chip thereof |
Families Citing this family (6)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US10185842B2 (en) | 2015-03-18 | 2019-01-22 | Intel Corporation | Cache and data organization for memory protection |
US9798900B2 (en) * | 2015-03-26 | 2017-10-24 | Intel Corporation | Flexible counter system for memory protection |
US9703492B2 (en) | 2015-05-19 | 2017-07-11 | International Business Machines Corporation | Page replacement algorithms for use with solid-state drives |
US10528485B2 (en) | 2016-09-30 | 2020-01-07 | Intel Corporation | Method and apparatus for sharing security metadata memory space |
TWI727236B (en) * | 2018-12-12 | 2021-05-11 | 瑞昱半導體股份有限公司 | Data bit width converter and system on chip thereof |
CN110059269B (en) * | 2019-03-21 | 2021-01-15 | 北京创鑫旅程网络技术有限公司 | Page tracking method and device, electronic equipment and computer readable storage medium |
Citations (1)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US7904661B2 (en) * | 2005-02-10 | 2011-03-08 | International Business Machines Corporation | Data stream prefetching in a microprocessor |
Family Cites Families (16)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
EP0976034B1 (en) * | 1996-01-24 | 2005-10-19 | Sun Microsystems, Inc. | Method and apparatus for stack caching |
US5987587A (en) * | 1997-06-06 | 1999-11-16 | International Business Machines Corporation | Single chip multiprocessor with shared execution units |
US6510475B1 (en) * | 1999-10-22 | 2003-01-21 | Intel Corporation | Data fetching control mechanism and method for fetching optimized data for bus devices behind host bridge |
US6654869B1 (en) * | 1999-10-28 | 2003-11-25 | International Business Machines Corporation | Assigning a group tag to an instruction group wherein the group tag is recorded in the completion table along with a single instruction address for the group to facilitate in exception handling |
US7822926B2 (en) * | 2007-04-16 | 2010-10-26 | Arm Limited | Cache memory |
US9569363B2 (en) | 2009-03-30 | 2017-02-14 | Via Technologies, Inc. | Selective prefetching of physically sequential cache line to cache line that includes loaded page table entry |
US8341380B2 (en) | 2009-09-22 | 2012-12-25 | Nvidia Corporation | Efficient memory translator with variable size cache line coverage |
US8250303B2 (en) * | 2009-09-30 | 2012-08-21 | International Business Machines Corporation | Adaptive linesize in a cache |
US9418011B2 (en) | 2010-06-23 | 2016-08-16 | Intel Corporation | Region based technique for accurately predicting memory accesses |
US8601216B2 (en) * | 2010-08-31 | 2013-12-03 | Oracle International Corporation | Method and system for removing cache blocks |
US8977819B2 (en) * | 2010-09-21 | 2015-03-10 | Texas Instruments Incorporated | Prefetch stream filter with FIFO allocation and stream direction prediction |
US9063860B2 (en) * | 2011-04-01 | 2015-06-23 | Intel Corporation | Method and system for optimizing prefetching of cache memory lines |
US9684601B2 (en) * | 2012-05-10 | 2017-06-20 | Arm Limited | Data processing apparatus having cache and translation lookaside buffer |
US9367471B2 (en) * | 2012-09-10 | 2016-06-14 | Apple Inc. | Fetch width predictor |
US9612972B2 (en) | 2012-12-03 | 2017-04-04 | Micron Technology, Inc. | Apparatuses and methods for pre-fetching and write-back for a segmented cache memory |
US10140138B2 (en) * | 2013-03-15 | 2018-11-27 | Intel Corporation | Methods, systems and apparatus for supporting wide and efficient front-end operation with guest-architecture emulation |
-
2014
- 2014-04-15 US US14/253,059 patent/US9513805B2/en not_active Expired - Fee Related
- 2014-09-11 US US14/483,550 patent/US9524100B2/en not_active Expired - Fee Related
-
2016
- 2016-12-19 US US15/383,306 patent/US9910781B2/en active Active
Patent Citations (1)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US7904661B2 (en) * | 2005-02-10 | 2011-03-08 | International Business Machines Corporation | Data stream prefetching in a microprocessor |
Cited By (1)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
CN111367846A (en) * | 2018-12-25 | 2020-07-03 | 瑞昱半导体股份有限公司 | Data bit width converter and system chip thereof |
Also Published As
Publication number | Publication date |
---|---|
US9513805B2 (en) | 2016-12-06 |
US9910781B2 (en) | 2018-03-06 |
US20170097892A1 (en) | 2017-04-06 |
US20150293855A1 (en) | 2015-10-15 |
US9524100B2 (en) | 2016-12-20 |
Similar Documents
Publication | Publication Date | Title |
---|---|---|
US9910781B2 (en) | Page table including data fetch width indicator | |
US10915466B2 (en) | System protecting caches from side-channel attacks | |
US9582423B2 (en) | Counter-based wide fetch management | |
JP6696987B2 (en) | A cache accessed using a virtual address | |
CN113412472A (en) | Directed interrupt virtualization with interrupt table | |
US11210102B2 (en) | Speculative buffer for speculative memory accesses with entries tagged with execution context identifiers | |
ES2787002T3 (en) | Procedure and apparatus for compression of cache labels | |
CN113412473A (en) | Directed interrupts for multi-level virtualization with interrupt tables | |
EP3757799B1 (en) | System and method to track physical address accesses by a cpu or device | |
US11645208B2 (en) | Translation bandwidth optimized prefetching strategy through multiple translation lookaside buffers | |
US9483180B2 (en) | Memory-area property storage including data fetch width indicator | |
US10949351B2 (en) | Bits register for synonyms in a memory system | |
US11977486B2 (en) | Shadow pointer directory in an inclusive hierarchical cache | |
US9727484B1 (en) | Dynamic cache memory management with translation lookaside buffer protection | |
US20190188154A1 (en) | Translation pinning in translation lookaside buffers | |
US9836405B2 (en) | Dynamic management of virtual memory blocks exempted from cache memory access | |
US11487874B1 (en) | Prime and probe attack mitigation | |
US20170220479A1 (en) | Dynamic cache memory management with cache pollution avoidance | |
US11379368B1 (en) | External way allocation circuitry for processor cores | |
US9495306B1 (en) | Dynamic management of a processor state with transient cache memory | |
US9396125B1 (en) | Dynamic management of memory ranges exempted from cache memory access |
Legal Events
Date | Code | Title | Description |
---|---|---|---|
AS | Assignment |
Owner name: INTERNATIONAL BUSINESS MACHINES CORPORATION, NEW Y Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNORS:GSCHWIND, MICHAEL K.;MOREIRA, JOSE E.;SINHAROY, BALARAM;SIGNING DATES FROM 20140402 TO 20140411;REEL/FRAME:032675/0876 |
|
STCF | Information on status: patent grant |
Free format text: PATENTED CASE |
|
FEPP | Fee payment procedure |
Free format text: MAINTENANCE FEE REMINDER MAILED (ORIGINAL EVENT CODE: REM.); ENTITY STATUS OF PATENT OWNER: LARGE ENTITY |
|
LAPS | Lapse for failure to pay maintenance fees |
Free format text: PATENT EXPIRED FOR FAILURE TO PAY MAINTENANCE FEES (ORIGINAL EVENT CODE: EXP.); ENTITY STATUS OF PATENT OWNER: LARGE ENTITY |
|
STCH | Information on status: patent discontinuation |
Free format text: PATENT EXPIRED DUE TO NONPAYMENT OF MAINTENANCE FEES UNDER 37 CFR 1.362 |
|
FP | Lapsed due to failure to pay maintenance fee |
Effective date: 20201206 |