System for native code execution

• US 7,971,032 B2
• Filed: 10/20/2008
• Issued: 06/28/2011
• Est. Priority Date: 11/14/2007
• Status: Expired due to Fees

• Current Assignee: Array Portfolio LLC
• Original Assignee: VNS Portfolio LLC
• Inventors: Shattuck, Charles W.
• Primary Examiner(s): Chan; Eddie P
• Assistant Examiner(s): Faherty; Corey
• Application Number:
  US12/254,709
• Publication Number:
  US 20090138677A1
• Time in Patent Office: 981 Days
• Field of Search: 712/209
• US Class Current: 712/209
• CPC Class Codes: G06F 9/45504 Abstract machines for programme code execution, e.g. Java virtual machine [JVM], interpreters, emulators

Abstract

A process, apparatus, and system to execute a program in an array of processor nodes that include an agent node and an executor node. A virtual program of tokens of different types represents the program and is provided in a memory. The types include a run type that includes native code instructions of the executer node. A token is loaded from the memory and executed in the agent node based on its type. In particular, if the token is an optional stop type execution ends and if the token is a run type the native code instructions in the token are sent to the executor node. The native code instructions are executed in the executor node as received from the agent node. And such loading and execution continues in this manner indefinitely or until a stop type token is executed.

Claims

1. A process to execute a program in an array of processor nodes including an agent node and an executor node, comprising:

(a) providing a virtual program in a memory to represent the program, wherein said virtual program includes a plurality of tokens of different types including at least one run type that includes native code instructions of the executer node;

(b) loading a said token from said memory into the agent node;

(c) executing said token in the agent node based on its said type, wherein if said token is a said run type said executing includes sending said native code instructions in said token to the executor node;

(d) executing said native code instructions as received from the agent node in the executor node; and

(e) continuing from said (b).

2. The process of claim 1, wherein said virtual program includes more said native code instructions than can be stored in the executor node.

3. The process of claim 1, wherein said memory is not in the same semiconductor die or dies as the agent node or the executor node.

4. The process of claim 1, wherein said plurality of tokens in said virtual program are of potentially ten said different types.

5. The process of claim 1, wherein said different types are members of the set consisting of said run type, a call type, a branch type, a fetch type, a store type, a return type, a next type, and conditional types.

6. The process of claim 1, wherein said plurality of tokens of different types further includes at least one stop type and if said token is a said stop type said executing in said (c) includes ending the process.

7. The process of claim 1, wherein said loading is performed at least in part by one or more of the processor nodes of the array of processor nodes other than the agent node or the executor node.

8. The process of claim 1, wherein said executing said token is performed in a state machine in the agent node.

9. The process of claim 1, wherein said executing said native code instructions is performed in a port of the executor node from which the executor node received said native code instructions from the agent node.

10. The process of claim 1, wherein said (c) includes maintaining a virtual program counter to specify a current location in said virtual program.

11. The process of claim 10, wherein said virtual program counter is maintained in a data stack in the agent node.

12. An apparatus for executing a program, comprising:

an array of at least two processor nodes, wherein one said processor node is an agent node and another said processor node is an executer node;

said agent node includes logics that;

maintain a virtual program counter;

obtain tokens from a memory of a virtual program that represent the program, wherein said tokens are of a plurality of different types including at least one run type that includes native code instructions of said executer node;

execute said tokens; and

write said native code instructions to said executer node; and

said executer node includes logics that;

read the native code instructions from said agent node; and

execute the native code instructions.

13. The apparatus of claim 12 wherein said memory is not in the same semiconductor die or dies as said agent node or said executor node.

14. The apparatus of claim 12, wherein said memory is a synchronous dynamic random access memory.

15. The apparatus of claim 12, wherein said plurality of tokens in said virtual program are of potentially ten said different types.

16. The apparatus of claim 12, wherein said different types are members of the set consisting of said run type, a call type, a branch type, a fetch type, a store type, a return type, a next type, and conditional types.

17. The apparatus of claim 12, wherein said plurality of tokens of different types further includes at least one stop type and if said agent node executes a said token that is a said stop type the apparatus is stopped.

18. The apparatus of claim 12, wherein said agent node includes a state machine in which said executing of said tokens is performed.

19. The apparatus of claim 12, wherein said executor node executes said native code instructions in a port from which said native code instructions are received from said agent node.

20. The apparatus of claim 12, wherein said agent node maintains said virtual program counter in a data stack.

21. The apparatus of claim 12, wherein said array includes at least one storage driver node assists said agent node in obtaining said tokens from said memory.

22. A system to execute a program in an array of processor nodes including an agent node and an executor node, comprising:

means for providing a virtual program in a memory to represent the program, wherein said virtual program includes a plurality of tokens of different types including at least one run type that includes native code instructions of the executer node;

means for loading a said token from said memory into the agent node;

means for executing said token in the agent node based on its said type, wherein if said token is a said run type said executing includes sending said native code instructions in said token to the executor node;

means for executing said native code instructions as received from the agent node in the executor node; and

means for returning to and continuing with said means for loading.