Software compiler generated threaded environment

• US 9,218,186 B2
• Filed: 09/01/2011
• Issued: 12/22/2015
• Est. Priority Date: 09/01/2011
• Status: Expired due to Fees

• Current Assignee: International Business Machines Corporation
• Original Assignee: International Business Machines Corporation
• Inventors: Silvera, Raul E., Zhang, Guansong, Zhao, Yue
• Primary Examiner(s): Zhen, Wei
• Assistant Examiner(s): HUDA, MOHAMMED NURUL
• Application Number:
  US13/223,486
• Publication Number:
  US 20130061000A1
• Time in Patent Office: 1,573 Days
• Field of Search: 717/151
• US Class Current: 1/1
• CPC Class Codes: G06F 8/45 Exploiting coarse grain parallelism in compilation, i.e. parallelism between groups of instructions
• CPC Class Codes: G06F 9/3009 Thread control instructions
• CPC Class Codes: G06F 9/3814 Implementation provisions of instruction buffers, e.g. prefetch buffer; banks
• CPC Class Codes: G06F 9/3851 from multiple instruction streams, e.g. multistreaming

Abstract

A computer-implemented method for creating a threaded package of computer executable instructions from software compiler generated code includes allocating, through a computer processor, the computer executable instructions into a plurality of stacks, differentiating between different types of computer executable instructions for each computer executable instruction allocated to each stack of the plurality of stacks, creating switch points for each stack of the plurality of stacks based upon the differentiating, and inserting the switch points within each stack of the plurality of stacks.

Claims

1. A computer-implemented method for creating a threaded package of computer executable instructions from software compiler generated code, comprising:

allocating, through a computer processor, the computer executable instructions into a plurality of stacks;

differentiating between different types of computer executable instructions for each computer executable instruction allocated to each stack of the plurality of stacks, wherein the differentiating comprises interpreting each computer executable instruction at a software compiler to differentiate between at least two different types of computer executable instructions, the at least two different types of computer executable instructions comprising a memory operation and a computation operation, wherein the memory operation comprises a transfer of information from a remote memory to a localized cache of a target processor, and wherein the computation operation is a computer executable instruction involving computation on information within the localized cache of the target processor;

creating, by the software compiler, switch points for each stack of the plurality of stacks based upon the differentiating;

inserting, by the software compiler, the created switch points directly after any computer executable instructions that were determined to be associated with a memory access by the differentiating within each stack of the plurality of stacks; and

executing the plurality of stacks of computer executable instructions after inserting the switch points, wherein the execution comprises;

based on execution of a first computer executable instruction in a first stack of the plurality of stacks, initiating a transfer of information from the remote memory to the localized cache or register of the target processor;

switching from the first stack to a second stack of the plurality of stacks based on a first switch point that is located directly after the first computer executable instruction in the first stack;

initiating execution of a second computer executable instruction in the second stack while processing the transfer of information from the remote memory to the localized cache associated with the first computer executable instruction in the first stack;

switching from the second stack to the first stack based on a second switch point that is located in the second stack after the second computer executable instruction; and

after switching from the second stack to the first stack, performing a third computer executable instruction in the first stack comprising the computation operation using the information in the localized cache that was transferred by the first computer executable instruction.

2. The method of claim 1, wherein the allocating comprises:

interpreting a function described by the computer executable instruction to be compiled through a software compiler;

dividing the function into one or more sets of computer executable instructions; and

allocating the one or more sets to associated stacks.

3. The method of claim 2, wherein the associated stacks are groups of sequential computer executable instructions.

4. The method of claim 3, wherein a total size of each group of sequential computer executable instructions is based upon a local buffer size available to a target processor for which the stacks are being created.

5. The method of claim 1, further comprising:

outputting the computer executable instructions associated with the plurality of stacks as a threaded package of computer executable instructions for a target processor.

6. A computer program product comprising a non-transitory computer readable storage medium having computer executable instructions stored thereon, that, when executed by a computer processor, direct the computer processor to perform a method for creating a threaded package of computer executable instructions from software compiler generated code, the method comprising:

allocating the computer executable instructions into a plurality of stacks;

differentiating between different types of computer executable instructions for each computer executable instruction allocated to each stack of the plurality of stacks, wherein the differentiating comprises interpreting each computer executable instruction at a software compiler to differentiate between at least two different types of computer executable instructions, the at least two different types of computer executable instructions comprising a memory operation and a computation operation, wherein the memory operation comprises a transfer of information from a remote memory to a localized cache of a target processor, and wherein the computation operation is a computer executable instruction involving computation on information within the localized cache of the target processor;

creating, by the software compiler, switch points for each stack of the plurality of stacks based upon the differentiating;

inserting, by the software compiler, the created switch points directly after any computer executable instructions that were determined to be associated with a memory access by the differentiating within each stack of the plurality of stacks; and

executing the plurality of stacks of computer executable instructions after inserting the switch points, wherein the execution comprises;

based on execution of a first computer executable instruction in a first stack of the plurality of stacks, initiating a transfer of information from the remote memory to the localized cache or register of the target processor;

switching from the first stack to a second stack of the plurality of stacks based on a first switch point that is located directly after the first computer executable instruction in the first stack;

initiating execution of a second computer executable instruction in the second stack while processing the transfer of information from the remote memory to the localized cache associated with the first computer executable instruction in the first stack;

switching from the second stack to the first stack based on a second switch point that is located in the second stack after the second computer executable instruction; and

after switching from the second stack to the first stack, performing a third computer executable instruction in the first stack comprising the computation operation using the information in the localized cache that was transferred by the first computer executable instruction.

7. The computer program product of claim 6, wherein the allocating comprises:

interpreting a function described by the computer executable instruction to be compiled through a software compiler;

dividing the function into one or more sets of computer executable instructions; and

allocating the one or more sets to associated stacks.

8. The computer program product of claim 7, wherein the associated stacks are groups of sequential computer executable instructions.

9. The computer program product of claim 8, wherein a total size of each group of sequential computer executable instructions is based upon a local buffer size available to a target processor for which the stacks are being created.

10. The computer program product of claim 6, wherein the method further comprises:

outputting the plurality of stacks as a threaded package of computer executable instructions for a target processor.

11. A software compiler system, comprising:

a memory configured to store computer executable instructions; and

a computer processor operatively coupled to the memory, wherein the computer processor is configured to perform a method for creating a threaded package of computer executable instructions from software compiler generated code, the method comprising;

allocating, through the computer processor, the computer executable instructions into a plurality of stacks;

differentiating between different types of computer executable instructions for each computer executable instruction allocated to each stack of the plurality of stacks, wherein the differentiating comprises interpreting each computer executable instruction at a software compiler to differentiate between at least two different types of computer executable instructions, the at least two different types of computer executable instructions comprising a memory operation and a computation operation, wherein the memory operation comprises a transfer of information from a remote memory to a localized cache of a target processor, and wherein the computation operation is a computer executable instruction involving computation on information within the localized cache of the target processor;

creating, by the software compiler, switch points for each stack of the plurality of stacks based upon the differentiating;

inserting, by the software compiler, the created switch points directly after any computer executable instructions that were determined to be associated with a memory access by the differentiating within each stack of the plurality of stacks; and

executing the plurality of stacks of computer executable instructions after inserting the switch points, wherein the execution comprises;

based on execution of a first computer executable instruction in a first stack of the plurality of stacks, initiating a transfer of information from the remote memory to the localized cache or register of the target processor;

switching from the first stack to a second stack of the plurality of stacks based on a first switch point that is located directly after the first computer executable instruction in the first stack;

initiating execution of a second computer executable instruction in the second stack while processing the transfer of information from the remote memory to the localized cache associated with the first computer executable instruction in the first stack;

switching from the second stack to the first stack based on a second switch point that is located in the second stack after the second computer executable instruction; and

after switching from the second stack to the first stack, performing a third computer executable instruction in the first stack comprising the computation operation using the information in the localized cache that was transferred by the first computer executable instruction.

12. The system of claim 11, further comprising:

a computer readable storage medium operatively coupled to the computer processor, the computer readable storage medium being configured to store computer executable instructions representing the method.

13. The system of claim 11, wherein the allocating comprises:

interpreting a function described by the computer executable instruction to be compiled through a software compiler;

dividing the function into one or more sets of computer executable instructions; and

allocating the one or more sets to associated stacks, wherein the associated stacks are groups of sequential computer executable instructions, and wherein a total size of each group of sequential computer executable instructions is based upon a local buffer size available to a target processor for which the stacks are being created.