Systems, apparatuses, and methods for a hardware and software system to automatically decompose a program to multiple parallel threads

1. A computer-implemented method comprising:

analyzing a single-threaded region of executing program code, the analysis including identifying dependencies of binary code within the single-threaded region;

determining portions of the single-threaded region of executing program code which may be executed in parallel based on the analysis that includes the identified dependencies of binary code within the single-threaded region;

assigning the portions to two or more parallel execution tracks; and

executing the portions in parallel across the assigned execution tracks.

2. The method as in claim 1 wherein the dependences include register-based dependencies and memory-based dependencies.

3. The method as in claim 1 wherein the operation of analyzing further comprises:

parsing a branch profile to extract branch and memory profile information for the executing program code region.

4. The method as in claim 3 wherein the operation of analyzing further comprises:

decoding basic blocks of the program code region by walking the branch profile.

5. The method as in claim 4 wherein the operation of analyzing further comprises:

identifying loops within the region of program code; and

responsively creating multiple versions of basic blocks within the loops, the multiple versions being capable of execution in parallel.

6. The method as in claim 5 wherein identifying loops comprises identifying back edges in a control flow representation of the region of program code.

7. The method as in claim 5 wherein creating multiple versions comprises renaming the loops to uniquely identify the different versions.

8. The method as in claim 5 further comprising:

performing a register dependence analysis and a memory dependence analysis to identify independently-executable regions of the program code.

9. The method as in claim 8 further comprising:

forming super-chains from the program code.

10. The method as in claim 9 wherein forming super-chains comprises the operations of:

identifying instructions in the program code which are not consumed by any other instruction;

using the instructions which are not consumed by any other instruction as seed nodes for each super-chain; and

building each super-chain from a seed node.

11. The method as in claim 9 further comprising:

assigning each super-chain to one of the parallel execution tracks.

12. The method as in claim 11 further comprising:

calculating an approximate execution time for each super-chain; and

assigning each super-chain to balance load across the parallel execution tracks.

13. The method as in claim 12 further comprising:

reducing duplication of instructions between different parallel execution tracks using multiple heuristics so that same processors resources are not being consumed in an overlapping manner.

14. The method as in claim 13 further comprising:

emitting code bytes associated with each of the parallel execution tracks; and

generating a backend table usable by processor hardware to synchronize execution across tracks and maintain the correct state of each of the parallel execution tracks.

15. The method as in claim 14 wherein emitting code bytes comprises converting from an intermediate representation of the program code to program code executable on the processor.

16. The method as in claim 14 wherein generating the backend table comprises:

traversing all basic blocks and responsively setting taken/not taken targets in the backend table;

setting in the backend table the type of control transfer for each basic block;

setting in the backend table load/store track bits for each basic block; and

determining, for memory instructions, the tracks that they belong to and responsively setting the track bits associated therewith in the backend table.