System and method for JIT memory footprint improvement for embedded java devices

• US 20050183077A1
• Filed: 02/12/2004
• Published: 08/18/2005
• Est. Priority Date: 02/12/2004
• Status: Abandoned Application

• Current Assignee: International Business Machines Corporation
• Original Assignee: International Business Machines Corporation
• Inventors: Orn, Mikael, Tracey, William J., Langdale, Philip Lee, Robbins, James Patrick
• Application Number:
  US10/777,908
• Publication Number:
  US 20050183077A1
• Time in Patent Office: Days
• US Class Current: 717/148
• CPC Class Codes: G06F 12/08 in hierarchically structured memory systems, e.g. virtual memory systems
• CPC Class Codes: G06F 9/45516 Runtime code conversion or optimisation

Abstract

A system and method for reclaiming memory occupied by compiled code resulting from a Just-in-Time (JIT) compiler is provided. An address space used to store code resulting from a JIT compiler is memory mapped using a special filesystem. A map is maintained identify method name and corresponding JIT pages. When the memory manager needs more space, it requests that the special filesystem write the data from memory back to nonvolatile storage. The special filesystem acts as if the data was written. When the code is subsequently called, a page fault and an invalid operation exception occur and are handled. The data in the map is used to recompile the method to the same address space and the faulting instruction is re-executed.

Claims

1. A computer implemented method of reclaiming memory occupied by Just-in-Time (JIT) compiled programs, said method comprising:

tracking a JIT compiled program, the tracking recording tracking data that includes a method name corresponding to the JIT compiled program and an address range that corresponds to the JIT compiled program;

discarding one or more memory pages included in the address range;

branching to an address included in one of the discarded pages, the branching resulting in a page fault;

retrieving the method name corresponding to the address that resulted in the page fault; and

executing a method corresponding to the retrieved method name.

2. The method of claim 1 wherein executing the method further comprises:

recompiling the method using a JIT compiler, the recompiling resulting in a replacement JIT compiled program stored at the recorded address range, wherein the executed method is the replacement JIT compiled program.

3. The method of claim 1 wherein executing the method further comprises:

removing the method name and the corresponding address range from the tracking data;

retrieving an interpretable form of the method; and

interpreting code included in the interpretable form of the method.

4. The method of claim 1 further comprising:

memory mapping the JIT compiled program from a nonvolatile storage location to the address range using a special filesystem;

prior to the discarding, receiving, at the special filesystem, an instruction to write (to nonvolatile storage) the one or more memory pages that are about to be discarded; and

returning a response indicating successful completion of the instruction without writing any of the pages to the nonvolatile storage location.

5. The method of claim 4 further comprising:

registering an error handler to handle a specific invalid operation code (opcode) prior to discarding any of the memory pages;

in response to the page fault, calling the special filesystem to load the one or more discarded memory pages from the nonvolatile storage location;

writing, by the special filesystem, one or more occurrences of the invalid opcode to one or more of the memory pages that were previously discarded; and

re-branching to the address that caused the page fault, the re-branching resulting in an invalid opcode exception.

6. The method of claim 5 further comprising:

executing the error handler in response to encountering the invalid opcode, wherein the executing includes;

retrieving the address range from the tracking data that includes the address that caused the page fault;

retrieving the method name from the tracking data, wherein the retrieved method name corresponds to the address range; and

re-compiling method code corresponding to the method name so that the re-compiled program is stored at the same address range as the original JIT compiled program.

7. The method of claim 6 further comprising:

branching a third time to the address that caused the page fault, the branching performed after the re-compiling; and

executing the re-compiled method code.

15. The computer program product of claim 1 wherein the means for executing the method further comprises:

means for recompiling the method using a JIT compiler, the recompiling resulting in a replacement JIT compiled program stored at recorded address range, wherein the executed method is the replacement JIT compiled program.

16. The computer program product of claim 1 wherein the means for executing the method further comprises:

means for removing the method name and the corresponding address range from the tracking data;

means for retrieving an interpretable form of the method; and

means for interpreting code included in the interpretable form of the method.

17. The computer program product of claim 1 further comprising:

means for memory mapping the JIT compiled program from a nonvolatile storage location to the address range using a special filesystem;

prior to the discarding, means for receiving, at the special filesystem, an instruction to write (to nonvolatile storage) the one or more memory pages that are about to be discarded; and

means for returning a response indicating successful completion of the instruction without writing any of the pages to the nonvolatile storage location.

18. The computer program product of claim 17 further comprising:

means for registering an error handler to handle a specific invalid operation code (opcode) prior to discarding any of the memory pages;

in response to the page fault, means for calling the special filesystem to load the one or more discarded memory pages from the nonvolatile storage location;

means for writing, by the special filesystem, one or more occurrences of the invalid opcode to the memory pages that were previously discarded; and

means for re-branching to the address that caused the page fault, the re-branching resulting in an invalid opcode exception.

19. The computer program product of claim 18 further comprising:

means for executing the error handler in response to encountering the invalid opcode, wherein the means for executing includes;

means for retrieving the address range from the tracking data that includes the address that caused the page fault;

means for retrieving the method name from the tracking data, wherein the retrieved method name corresponds to the address range; and

means for re-compiling method code corresponding to the method name so that the re-compiled program is stored at the same address range as the original JIT compiled program.

20. The computer program product of claim 19 further comprising:

means for branching a third time to the address that caused the page fault, the branching performed after performing the means for re-compiling; and

means for executing the re-compiled method code.

8. An information handling system comprising:

one or more processors;

a memory accessible by the processors;

a nonvolatile storage device accessible by the processors;

a virtual machine that includes a Just-in-Time (JIT) compiler loaded from the nonvolatile storage device to the memory and executed by the processors;

a memory reclamation tool for reclaiming memory occupied by JIT compiled programs, the memory reclamation tool including software code effective to;

track a JIT compiled program, the tracking including software code effective to record tracking data that includes a method name corresponding to the JIT compiled program and an address range that corresponds to the JIT compiled program;

discard one or more memory pages included in the address range;

branch to an address included in one of the discarded pages resulting in a page fault;

retrieve, from the tracking data, the method name corresponding to the address that resulted in the page fault; and

execute a method corresponding to the retrieved method name.

9. The information handling system of claim 8 wherein the software code effective to execute the method further comprises software code effective to:

recompile the method using the JIT compiler, the recompiling resulting in a replacement JIT compiled program stored at the recorded address range, wherein the executed method is the replacement JIT compiled program.

10. The information handling system of claim 8 wherein the software code effective to execute the method further comprises software code effective to:

remove the method name and the corresponding address range from the tracking data;

retrieve an interpretable form of the method; and

interpret code included in the interpretable form of the method.

11. The information handling system of claim 8 further comprising software code effective to:

memory map the JIT compiled program from a nonvolatile storage location to the address range using a special filesystem;

prior to the discarding, receive, at the special filesystem, an instruction to write (to the nonvolatile storage device) the one or more memory pages that are about to be discarded; and

return a response indicating successful completion of the instruction without writing any of the pages to the nonvolatile storage location.

12. The information handling system of claim 11 further comprising software code effective to:

register an error handler to handle a specific invalid operation code (opcode) prior to discarding any of the memory pages;

in response to the page fault, call the special filesystem to load the one or more discarded memory pages from the nonvolatile storage location;

write, by the special filesystem, one or more occurrences of the invalid opcode to one or more of the memory pages that were previously discarded; and

re-branch to the address that caused the page fault, the re-branch resulting in an invalid opcode exception.

13. The information handling system of claim 12 further comprising software code effective to:

execute the error handler in response to encountering the invalid opcode, wherein the execution of the error handler includes software code effective to;

retrieve the address range from the tracking data that includes the address that caused the page fault;

retrieve the method name from the tracking data, wherein the retrieved method name corresponds to the address range;

re-compile method code corresponding to the method name so that the re-compiled program is stored at the same address range as the original JIT compiled program;

branch a third time to the address that caused the page fault, the branching performed after the re-compiling; and

execute the re-compiled method code.

14. A computer program product stored on a computer operable media for reclaiming memory occupied by Just-in-Time (JIT) compiled programs, said computer program product comprising:

means for tracking a JIT compiled program, the tracking recording tracking data that includes a method name corresponding to the JIT compiled program and an address range that corresponds to the JIT compiled program;

means for discarding one or more memory pages included in the address range;

means for branching to an address included in one of the discarded pages, the branching resulting in a page fault;

means for retrieving the method name corresponding to the address that resulted in the page fault; and

means for executing a method corresponding to the retrieved method name.