System and method for persisting dynamically generated code in a directly addressable and executable storage medium

• US 20040054994A1
• Filed: 09/17/2002
• Published: 03/18/2004
• Est. Priority Date: 09/17/2002
• Status: Active Grant

• Current Assignee: Microsoft Technology Licensing LLC (Microsoft Corporation)
• Original Assignee: Microsoft Corporation
• Inventors: Smith, Brian J., Demsey, Seth M., Smith, Michael D., Zintel, W. Michael, Corbin, Scott M.
• Granted Patent: US 7,246,346 B2
• Time in Patent Office: Days
• US Class Current: 717/148
• CPC Class Codes: G06F 9/45516 Runtime code conversion or optimisation

Abstract

The present invention is directed at a virtual machine environment operating on portable devices with limited resources. The virtual machine environment includes a method for compiling an intermediate language into native code wherein the native code is stored in a directly addressable and executable storage medium, such as flash memory. A portion of the native code is written to a cache resident in volatile memory during compiling. The cache is written to the directly addressable and executable storage medium. The cache may be sized in relation to a block size associated with the directly addressable and executable storage medium. A metadata map is maintained and associates a physical address at which the native code is stored in the storage medium with the method. The native code is persisted by storing the metadata map in the storage medium and associating the metadata map with the method.

Claims

1. A computer-implemented method for persisting dynamically generated code, the method comprising:

receiving a request for a method coded within a CPU-independent file;

compiling the method into CPU-dependent instructions during run-time;

storing the CPU-dependent instructions in a non-volatile memory; and

executing the CPU-dependent instructions.

2. The computer-implemented method of claim 1, wherein executing the CPU-dependent instructions further comprises executing the CPU-dependent instructions directly from the non-volatile memory.

3. The computer-implemented method of claim 1, wherein the CPU-independent file is written in an intermediate language.

4. The computer-implemented method of claim 1, wherein the intermediate language is a compiled version of a source file.

5. The computer-implemented method of claim 1, wherein storing the CPU-dependent instructions comprises writing a portion of the CPU-dependent instructions into a cache that is resident within a volatile memory and writing the cache into the non-volatile memory.

6. The computer-implemented method of claim 5, wherein the cache is sized in relation to a block size associated with the non-volatile memory.

7. The computer-implemented method of claim 5, wherein writing the cache into the non-volatile memory occurs after the method is finished compiling.

8. The computer-implemented method of claim 5, wherein writing the cache into the non-volatile memory occurs after the cache is full.

9. The computer-implemented method of claim 1, further comprising updating a metadata map with a physical address at which the CPU-dependent instructions are stored in the non-volatile memory.

10. The computer-implemented method of claim 9, wherein the metadata map is stored in the non-volatile memory.

11. The computer-implemented method of claim 10, further comprising determining whether the CPU-dependent instructions associated with the method are stored in the non-volatile memory, and if so, executing the CPU-dependent instructions without performing the compiling and storing steps.

12. The computer-implemented method of claim 11, wherein determining whether the CPU-dependent instructions are stored in the non-volatile memory includes reading the metadata map to determine whether the physical address is stored therein.

13. A system that persists dynamically generated native code, the system comprising:

a processor;

a volatile memory;

a non-volatile memory; and

a virtual machine, comprising;

a native code compiler configured to dynamically compile a method written in CPU-independent code into a corresponding native code and to store the corresponding native code in the non-volatile memory; and

an execution engine configured to directly address the corresponding native code stored in the non-volatile memory and to execute the corresponding native code without copying the native code to the volatile memory.

14. The system of claim 13, wherein the native code compiler is further configured to store the corresponding native code in a cache in the volatile memory before storing the native code in the non-volatile memory.

15. The system of claim 14, wherein the cache is in relation to a block size associated with the non-volatile memory and storing occurs after the cache is full.

16. The system of claim 14, wherein storing occurs after the cache is full.

17. The system of claim 14, wherein storing occurs after the method is compiled.

18. The system of claim 13, wherein the virtual machine maintains a metadata map that identifies an address at which the method is stored in the non-volatile memory.

19. The system of claim 18, wherein the metadata map is written to the non-volatile memory and the virtual machine reads the metadata map to determine whether the corresponding native code exists in the non-volatile memory, and if so, executing the corresponding native code without performing the compiling and the storing.

20. The system of claim 13, wherein the non-volatile memory comprises an directly addressable and executable storage medium.

21. The system of claim 20, wherein the non-volatile memory includes flash memory.

22. A computer-readable medium having computer-executable instructions for persisting dynamically generate code, the instructions comprising:

compiling a method written in CPU-independent instructions into native code during run-time;

storing the native code into a non-volatile memory; and

executing the native code directly from the non-volatile memory.

23. The computer-readable medium of claim 22, wherein storing the native code comprises writing a portion of the native code into a cache that is resident within a volatile memory and writing the cache into the non-volatile memory.

24. The computer-readable medium of claim 23, wherein writing the cache into the non-volatile memory occurs after the method is finished compiling.

25. The computer-readable medium of claim 23, wherein writing the cache into the non-volatile memory occurs after the cache is full.

26. The computer-readable medium of claim 22, further comprising maintaining a metadata map by writing a physical address at which the native code is stored in the non-volatile memory into the metadata map, the physical address being associated with the method in the metadata map.