Analyzing a managed runtime cache is provided. A heap associated with a managed runtime environment, where the heap includes an N-generation cache or a plurality of objects associated with a program operating within a managed runtime environment is identified. A snapshot of the heap is produced, wherein the snapshot identifies a memory location for each object of the plurality of objects at which the object is stored. A generation of each of the plurality of objects based, at least in part, on the memory location of the object is determined. One or more suggestions based, at least in part, on the memory location of the plurality of objects is provided.
Legal claims defining the scope of protection. Each claim is shown in both the original legal language and a plain English translation.
1. A computer program product (CPP) for use with a managed runtime cache, the CPP comprising: a storage device; and computer code stored in the storage device, with the computer code including machine readable instructions and data for causing a computer to perform operations including at least the following: during runtime of a set of application(s), performing garbage collection on the managed runtime cache under a garbage collection policy such that there is a heap of data identifying garbage under collection with the heap being logically organized into a plurality of N generations, determining that an application state with respect to the set of applications is steady, responsive to the determination that the application state is steady, generating a first snapshot of the heap, locating a cache container object corresponding to the managed runtime cache in the heap, for each given object of a plurality of objects in the managed runtime cache: finding the given object in the heap, determining a generation value of the given object based on memory segments, mapping an address of the given object to the memory segments used in the determination of the generation value, and recording the generation value of the given object, and for each given generation of the plurality of N generations of the heap, calculating a proportion of cached objects having a generation value equal to the given generation; and determining that the proportion of cached objects in a base generation is above a predetermined threshold; and determining that a cache implementation algorithm is functioning with substandard efficiency based, at least in part, on the determination that the proportion of cached objects in a base generation is above the predetermined threshold.
A computer program analyzes a managed runtime cache during application runtime. It monitors garbage collection on the cache, which organizes data into N generations. When the application reaches a steady state, the program takes a snapshot of the heap. It locates a specific cache container object and then analyzes each object within the cache to determine its generation based on memory segments. The program calculates the proportion of cached objects in each generation. If the proportion of objects in the base generation exceeds a threshold, the program determines the cache implementation algorithm is inefficient.
2. The CPP of claim 1 wherein the computer code further includes machine readable instructions and data for causing the processor(s) set to perform operation: responsive to the determination that the cache implementation algorithm is functioning with substandard efficiency, increasing the size of the cache.
Building on the cache analysis, if the program determines the cache implementation algorithm is inefficient because too many cached objects are in the base generation, it responds by increasing the size of the cache to improve performance. This adjustment aims to redistribute objects across generations and optimize cache utilization. The computer program product from the previous cache analysis monitors garbage collection on the cache, which organizes data into N generations. When the application reaches a steady state, the program takes a snapshot of the heap. It locates a specific cache container object and then analyzes each object within the cache to determine its generation based on memory segments. The program calculates the proportion of cached objects in each generation. If the proportion of objects in the base generation exceeds a threshold, the program determines the cache implementation algorithm is inefficient.
3. The CPP of claim 1 wherein the computer code further includes machine readable instructions and data for causing the processor(s) set to perform operation: responsive to the determination that the cache implementation algorithm is functioning with substandard efficiency, decreasing the size of cache.
Building on the cache analysis, if the program determines the cache implementation algorithm is inefficient because too many cached objects are in the base generation, it responds by decreasing the size of the cache to improve performance. This adjustment aims to force more frequent garbage collection cycles and potentially improve object distribution. The computer program product from the previous cache analysis monitors garbage collection on the cache, which organizes data into N generations. When the application reaches a steady state, the program takes a snapshot of the heap. It locates a specific cache container object and then analyzes each object within the cache to determine its generation based on memory segments. The program calculates the proportion of cached objects in each generation. If the proportion of objects in the base generation exceeds a threshold, the program determines the cache implementation algorithm is inefficient.
4. A computer system for use with a managed runtime cache, the computer system comprising: a processor(s) set; a storage device structured and connected to store code in a manner so that the code can be executed by the processor(s) set; and computer code stored in the storage device, with the computer code including machine readable instructions and data for causing the processor(s) set to perform operations including at least the following: during runtime of a set of application(s), performing garbage collection on the managed runtime cache under a garbage collection policy such that there is a heap of data identifying garbage under collection with the heap being logically organized into a plurality of N generations, determining that an application state with respect to the set of applications is steady, responsive to the determination that the application state is steady, generating a first snapshot of the heap, locating a cache container object corresponding to the managed runtime cache in the heap, for each given object of a plurality of objects in the managed runtime cache: finding the given object in the heap, determining a generation value of the given object based on memory segments, mapping an address of the given object to the memory segments used in the determination of the generation value, and recording the generation value of the given object, and for each given generation of the plurality of N generations of the heap, calculating a proportion of cached objects having a generation value equal to the given generation; and determining that the proportion of cached objects in a base generation is above a predetermined threshold; and determining that a cache implementation algorithm is functioning with substandard efficiency based, at least in part, on the determination that the proportion of cached objects in a base generation is above the predetermined threshold.
A computer system analyzes a managed runtime cache during application runtime. It monitors garbage collection on the cache, which organizes data into N generations. When the application reaches a steady state, the system takes a snapshot of the heap. It locates a specific cache container object and then analyzes each object within the cache to determine its generation based on memory segments. The system calculates the proportion of cached objects in each generation. If the proportion of objects in the base generation exceeds a threshold, the system determines the cache implementation algorithm is inefficient.
5. The computer system of claim 4 wherein the computer code further includes machine readable instructions and data for causing the processor(s) set to perform operation: responsive to the determination that the cache implementation algorithm is functioning with substandard efficiency, increasing the size of the cache.
Building on the cache analysis system, if the system determines the cache implementation algorithm is inefficient because too many cached objects are in the base generation, it responds by increasing the size of the cache to improve performance. This adjustment aims to redistribute objects across generations and optimize cache utilization. The computer system from the previous cache analysis monitors garbage collection on the cache, which organizes data into N generations. When the application reaches a steady state, the system takes a snapshot of the heap. It locates a specific cache container object and then analyzes each object within the cache to determine its generation based on memory segments. The system calculates the proportion of cached objects in each generation. If the proportion of objects in the base generation exceeds a threshold, the system determines the cache implementation algorithm is inefficient.
6. The computer system of claim 4 wherein the computer code further includes machine readable instructions and data for causing the processor(s) set to perform operation: responsive to the determination that the cache implementation algorithm is functioning with substandard efficiency, decreasing the size of cache.
Building on the cache analysis system, if the system determines the cache implementation algorithm is inefficient because too many cached objects are in the base generation, it responds by decreasing the size of the cache to improve performance. This adjustment aims to force more frequent garbage collection cycles and potentially improve object distribution. The computer system from the previous cache analysis monitors garbage collection on the cache, which organizes data into N generations. When the application reaches a steady state, the system takes a snapshot of the heap. It locates a specific cache container object and then analyzes each object within the cache to determine its generation based on memory segments. The system calculates the proportion of cached objects in each generation. If the proportion of objects in the base generation exceeds a threshold, the system determines the cache implementation algorithm is inefficient.
7. A computer program product (CPP) for use with a managed runtime cache, the CPP comprising: a storage device; and computer code stored in the storage device, with the computer code including machine readable instructions and data for causing a computer to perform operations including at least the following: during runtime of a set of application(s), performing garbage collection on the managed runtime cache under a garbage collection policy such that there is a heap of data identifying garbage under collection with the heap being logically organized into a plurality of N generations, determining that an application state with respect to the set of applications is steady, responsive to the determination that the application state is steady, generating a first snapshot of the heap, locating a cache container object corresponding to the managed runtime cache in the heap, for each given object of a plurality of objects in the managed runtime cache: finding the given object in the heap, determining a generation value of the given object based on memory segments, mapping an address of the given object to the memory segments used in the determination of the generation value, and recording the generation value of the given object, and for each given generation of the plurality of N generations of the heap, calculating a proportion of cached objects having a generation value equal to the given generation; and determining that the proportion of cached objects in a base generation is above a predetermined threshold; and determining that the performance of garbage collection is functioning with substandard efficiency based, at least in part, on the determination that the proportion of cached objects in a base generation is above the predetermined threshold.
A computer program analyzes a managed runtime cache during application runtime. It monitors garbage collection on the cache, which organizes data into N generations. When the application reaches a steady state, the program takes a snapshot of the heap. It locates a specific cache container object and then analyzes each object within the cache to determine its generation based on memory segments. The program calculates the proportion of cached objects in each generation. If the proportion of objects in the base generation exceeds a threshold, the program determines that garbage collection itself is functioning with substandard efficiency.
8. The CPP of claim 7 wherein the computer code further includes machine readable instructions and data for causing the processor(s) set to perform operation: responsive to the determination that the performance of garbage collection is functioning with substandard efficiency, changing the garbage collection policy.
Building on the cache analysis where garbage collection efficiency is assessed, the program, upon determining that garbage collection is functioning inefficiently (based on the proportion of cached objects in the base generation exceeding a threshold), responds by changing the garbage collection policy. This may involve switching algorithms or adjusting parameters to improve object lifespan management and reduce base generation accumulation. The computer program product from the previous cache analysis monitors garbage collection on the cache, which organizes data into N generations. When the application reaches a steady state, the program takes a snapshot of the heap. It locates a specific cache container object and then analyzes each object within the cache to determine its generation based on memory segments. The program calculates the proportion of cached objects in each generation. If the proportion of objects in the base generation exceeds a threshold, the program determines that garbage collection itself is functioning with substandard efficiency.
Cooperative Patent Classification codes for this invention. Click any code to explore related patents in that topic.
December 11, 2014
August 15, 2017
Browse 5M+ US patents with plain-English claim translations and AI-generated analysis.