Effective elimination of delay slot handling from a front section of a processor pipeline

• US 7,634,644 B2
• Filed: 09/21/2006
• Issued: 12/15/2009
• Est. Priority Date: 03/13/2006
• Status: Active Grant

• Current Assignee: Oracle America, Inc. (Oracle Corporation)
• Original Assignee: Sun Microsystems Incorporated (Oracle Corporation)
• Inventors: Jacobson, Quinn A., Chaudhry, Shailender, Tremblay, Marc
• Primary Examiner(s): Chan; Eddie P
• Assistant Examiner(s): Alrobaye; Idriss N
• Application Number:
  US11/534,125
• Publication Number:
  US 20070226475A1
• Time in Patent Office: 1,181 Days
• Field of Search: 712/233, 712/234, 712/236
• US Class Current: 712/234
• CPC Class Codes: G06F 9/3804 for branches, e.g. hedging, branch folding
• CPC Class Codes: G06F 9/3842 Speculative instruction execution
• CPC Class Codes: G06F 9/3867 using instruction pipelines

Abstract

Architectural techniques and implementations that defer enforcement of certain delayed control transfer instruction (DCTI) sequencing constraints or conventions to later stages of an execution pipeline are described. In this way, complexity of a processor pipeline front-end (including fetch sequencing) can be simplified, at least in-part, by fetching instructions generally without regard to such constraints or conventions. Instead, enforcement of such sequencing constraints and/or conventions may be deferred to one or more pipeline stages associated with commitment or retirement of instructions. Higher fetch bandwidth may be achieved in some realizations when, for example, DCTI couples are encountered in an execution sequence.

Claims

1. A computing apparatus configured to execute an instruction set that includes at least one delayed control transfer type instruction (DCTI), the computing apparatus comprising:

a pipeline front-end for fetching instructions from an instruction store without regard to an architecturally-defined special branching behavior for program sequences that include a second DCTI in a delay slot of a first DCTI, wherein the pipeline front-end lacks capability to determine proper execution order for nested DCTIs within fetched groups of instructions; and

a downstream pipeline section configured (i) to identify in a speculatively executed instruction sequence including at least one subsequence that is inconsistent with the architecturally-defined special branching behavior, the at least one subsequence containing the second DCTI in the delay slot of the first DCTI, and (ii) to enforce the architecturally-defined special branching behavior wherein said downstream pipeline section is located in the pipeline after an execution section.

2. The computing apparatus of claim 1,

wherein the downstream pipeline section includes a commit stage for committing executed instructions to architectural state, the commit stage enforcing the architecturally-defined special branching behavior.

3. The computing apparatus of claim 1,

wherein the pipeline front-end lacks capability to determine proper execution order for DCTI couples within fetched groups of instructions.

4. The computing apparatus of claim 1,

wherein the architecturally-defined special branching behavior includes a requirement that, for an instruction sequence that contains a DCTI couple, for which both branches are at least predicted taken, control is transferred briefly to the target of the first DCTI of the couple and then to the target of the second.

5. The computing apparatus of claim 1,

wherein the downstream pipeline section, upon detecting nested predicted taken DCTIs, is configured to determine proper instruction execution order and to cause the pipeline front-end to fetch additional instruction groups accordingly.

6. The computing apparatus of claim 1,

wherein the downstream pipeline section, upon detecting a second consecutive predicted taken DCTI, is configured to determine a proper next program counter (NPC) value and to cause the pipeline front end to fetch a next instruction at an address indicated by the NPC.

7. The computing apparatus of claim 1,

wherein the downstream pipeline section, upon detecting a second consecutive predicted taken DCTI, is configured to step through a group of successive instructions until a predetermined number of consecutive instructions other than DCTIs are executed, by successively determining a next program counter (NPC) value for each stepped instruction and causing the pipeline front-end to fetch an instruction at an address indicated by the NPC.

8. The computing apparatus of claim 1, configured as a multiple instruction issue, in-order issue processor.

9. The computing apparatus of claim 1, further comprising:

multiple execution pipelines sharing the pipeline front-end, each execution pipeline comprising at least one fetch buffer for storing one or more groups of fetched instructions.

10. The computing apparatus of claim 1, embodied as a multi-core processor integrated circuit.

11. The computing apparatus of claim 1, embodied as one or more computer readable storage media encoding a design file representation of a processor integrated circuit.

12. The computing apparatus of claim 1, embodied as a computer system and further comprising:

a memory interface coupled to the instruction store; and

a memory hierarchy coupled to the memory interface.

13. A multi-core processor comprising:

plural implemented cores sharing a front-end section that fetches instructions, without regard to an architecturally-defined special branching behavior for program sequences that include a second DCTI in a delay slot of a first DCTI, to be executed in functional units of the cores, wherein the front-end section lacks capability to determine proper execution order for nested delayed control transfer type instructions (DCTIs) within fetched groups of instructions; and

commit logic (i) to identify in a speculatively executed instruction sequence including at least one subsequence that is inconsistent with an instruction set defined special branching behavior, the at least one subsequence containing a second DCTI in a delay slot of a first DCTI, and (ii) to enforce the instruction set defined special branching behavior for the at least one subsequence rather than in fetch sequencing logic of the front-end section.

14. The multi-core processor of claim 13, further comprising:

an instruction store from which the front-end section fetches instructions.

15. The multi-core processor of claim 13,

wherein the front-end section fetches instructions without regard to the instruction set defined special branching behavior.

16. The multi-core processor of claim 13, in combination with, and coupled to, a memory hierarchy in which the first and second DCTIs span a cache line boundary.

17. A method of operating a processor configured to execute an instruction set that includes at least one delayed control transfer type instruction (DCTI), the method comprising:

fetching instructions from an instruction store without regard to an architecturally-defined special branching behavior for program sequences that include a second DCTI in a delay slot of a first DCTI, wherein a pipeline front-end section that fetches the instructions lacks capability to determine proper execution order for nested DCTIs within fetched groups of instructions;

speculatively executing instruction sequences including at least one subsequence that is inconsistent with the architecturally-defined special branching behavior; and

identifying in the speculatively executed instruction sequences, a subsequence containing the second DCTI in the delay slot of the first DCTI and enforcing the architecturally-defined special branching behavior wherein said identifying and enforcement is performed in a pipeline section located in the pipeline after an execution section.

18. The method of claim 17, further comprising:

selectively committing executed instructions to architectural state in a commit stage of the processor, the commit stage enforcing the architecturally-defined special branching behavior.

19. The method of claim 17, further comprising:

directing further fetching of instructions from the instruction store based on results of the post-speculative execution enforcement of the architecturally-defined special branching behavior.