Method and System for Stack-Caching Method Frames

1. A method for stack-caching method frames used with a stack-based processor using a frame size overflow (FSO) flag to control its execution mode, the method comprising the steps of: (A) storing at least one method frame in a memory stack or a stack cache for operating, invoking method, and returning and accessing local variables, wherein the stack cache has a capacity limit; (B) if the FSO flag is in a clear state and a size of a next method frame is larger than the capacity limit, changing the FSO flag into a set state and moving content in the stack cache to the memory stack so that the memory stack serves to store said method frame; (C) if the FSO flag is in the clear state and the size of next method frame is smaller than the capacity limit, storing the method frame in the stack cache; (D) if the FSO flag is in the set state and the size of the next method frame is smaller than the capacity limit, changing the FSO flag into the clear state and activating an auto spill and fill mechanism so that the stack cache serves to store the method frame for accessing data; and (E) if the FSO flag is in the set state and the size of the next method frame is larger than the capacity limit, storing the method frame in the memory stack.

2. The method as claimed in claim 1 , wherein the size of the method frame includes plural kinds of data.

3. The method as claimed in claim 2 , wherein the plural kinds of data includes the number of local variables, frame states and operand stacks.

4. The method as claimed in claim 2 , wherein the plural kinds of data are predetermined.

5. The method as claimed in claim 1 , wherein in steps (B) and (E), a Java method corresponding to the stored method frame is executed by software and an access to the Java method is performed via the memory stack.

6. The method as claimed in claim 1 , wherein in steps (C) and (D), a Java method corresponding to the stored method frame is performed by hardware and an access to the Java method is performed via the stack cache.

7. A system for stack-caching method frames comprising: a stack cache for temporarily storing at least one method frame having a size, the stack cache having a capacity limit; a memory having a handler table and a memory stack for storing a method frame that exceeds the capacity limit; and a processor having a frame size overflow (FSO) flag for controlling its execution mode; wherein when the FSO flag is in a set state, the processor executes a method corresponding to a method frame stored in memory stack through the memory stack and the handler table, and when the FSO flag is in a clear state, the processor executes a method corresponding to a method frame stored in the stack cache through the stack cache.

8. The system as claimed in claim 7 , wherein the handler table has a plurality of method addresses, each corresponding to a bytecode, for allowing the processor to obtain a method address from the handler table so that a virtual machine can jump to the method address to execute the bytecode by software.

9. The system as claimed in claim 7 , wherein the processor uses the stack cache to execute a Java method through the stack cache directly by hardware, the Java method corresponding to the stored method frame.

10. The system as claimed in claim 7 , wherein when the FSO flag is in the clear state and the size of next method frame is larger than the capacity limit, the FSO flag is changed into the set state and content of the stack cache is moved to the memory stack so that the memory stack is stored with the method frame.

11. The system as claimed in claim 7 , wherein when the FSO flag is in the clear state and the size of a next method frame is smaller than the capacity limit, the method frame is directly stored in the stack cache.

12. The system as claimed in claim 7 , wherein when the FSO flag is in the set state and the size of the next method frame is smaller than the capacity limit, the FSO flag is changed into the clear state and content of the stack cache is moved to the memory stack so that the memory stack is stored with the method frame, and an auto spill and fill mechanism is enabled so that the method frame is placed in the stack cache for being accessed.

13. The system as claimed in claim 7 , wherein when the FSO flag is in a set state and the size of the next method frame is larger than the capacity limit, the method frame is directly placed in the memory stack.

14. The system as claimed in claim 7 , wherein the size of the method frame includes plural kinds of data.

15. The system as claimed in claim 14 , wherein the plural kinds of data includes the number of local variables, frame states and operand stacks.

16. The system of claim 15 , wherein the plural kinds of data are predetermined.