Systems, methods, and apparatuses to decompose a sequential program into multiple threads, execute said threads, and reconstruct the sequential execution

1. An apparatus comprising:

a plurality of data cache units (DCUs) to store locally retired instructions of speculatively executed threads, wherein the DCUs include a version bit per line to classify an speculative update status of each line;

a merging level cache (MLC) coupled to the DCUs to merge data from the lines of the DCUs, wherein the MLC includes a speculative bit per cache line to indicate that a cache line contains a speculative state and last version bits to indicate which core of a plurality of cores that made a last change to a chunk, wherein a chunk is a granularity at which memory disambiguation between two speculative threads is detectable; and

a inter-core memory coherency module (ICMC) to globally retire instructions of the speculatively executed threads in the MLC.

2. The apparatus of claim 1 , wherein the ICMC further comprises:

a plurality of memory first in, first out (FIFO) queues to store ordering instructions of speculatively executed threads after they are retired, wherein each entry in the memory FIFO queues includes a program order pointer (POP) to identify a head of the memory FIFO queue where a next instruction to commit resides.

3. The apparatus of claim 2 , wherein the ICMC further comprises:

a switch to change between the memory FIFO queues during flow reconstruction by the ICMC.

4. The apparatus of claim 2 , wherein the ICMC further comprises:

an update description table (UDT) to identify lines of the MLC to be updated by store instructions located in the memory FIFO queues.

5. The apparatus of claim 3 , wherein the ICMC further comprises:

register checkpointing logic to rollback to a previous state to correct a misspeculation during execution of the speculatively executed threads.

6. The apparatus of claim 1 , further comprising:

a plurality of functional units to process the instructions of the speculatively executed threads.

7. The apparatus of claim 1 , further comprising L3 cache coupled to the MLC.

8. A method comprising:

speculatively executing a first and a second thread from a region of code in a first and a second processing core respectively;

locally retiring each instruction of the first and second threads locally in a first level cache of each of the first and second processing cores;

globally retiring each instruction of the first and second threads in a shared merging level cache, wherein the shared merging level cache includes a speculative bit per cache line to indicate that a cache line contains a speculative state and last version bits to indicate which core of a plurality of cores that made a last change to a chunk, wherein a chunk is a granularity at which memory disambiguation between two speculative threads is detectable;

storing each executed ordering instruction of the first and second threads in a memory first in, first out (FIFO) queue corresponding to each of the first and second processing cores;

determining a condition that occurred during the execution of the first and second threads that requires a flow of the region of code to be reconstructed; and

reconstructing the flow of the region of code using stored executed ordering instructions.

9. The method of claim 8 , further comprising:

reading a first ordering instruction of the speculatively executed region of code stored in a first memory FIFO queue;

reading a program order pointer (POP) value associated with the first ordering instruction; and

switching to a second memory FIFO queue and reading a first stored instruction when the POP value indicates a memory FIFO switch.

10. The method of claim 9 , wherein the POP value is a one-bit value stored in the memory FIFO.

11. The method of claim 9 , further comprising:

reading a next stored instruction of the memory FIFO queue when the POP value indicates no memory FIFO switch.

12. The method of claim 8 , wherein software perform the reconstructing the flow of the region of code using stored executed ordering instructions.

13. The method of claim 8 , wherein a hardware inter-core memory coherency module (ICMC) performs the reconstructing the flow of the region of code using stored executed ordering instructions.