Software scoreboard information and synchronization
Embodiments described herein provide a graphics processor in which dependency tracking hardware is simplified via the use of compiler provided software scoreboard information. In one embodiment the shader compiler for shader programs is configured to encode software scoreboard information into each instruction. Dependencies can be evaluated by the shader compiler and provided as scoreboard information with each instruction. The hardware can then use the provided information when scheduling instructions. In one embodiment, a software scoreboard synchronization instruction is provided to facilitate software dependency handling within a shader program. Using software to facilitate software dependency handling and synchronization can simplify hardware design, reducing the area consumed by the hardware. In one embodiment, dependencies can be evaluated by the shader compiler instead of the GPU hardware. The compiler can then insert a software scoreboard sync immediate instruction into compiled program code to manage instruction dependencies and prevent data hazards from occurring.
1. A graphics processor having software-based data hazard detection, the graphics processor comprising:
an instruction decoder to decode an instruction into a decoded instruction, the instruction including one or more operands to identify an operation of one or more instructions having data dependents, wherein the instruction decoder is further to decode one or more identifiers and an operation from the one or more operands; and
a graphics processing engine including hardware to execute the decoded instruction, the decoded instruction to cause the graphics processing engine to block completion of the decoded instruction until completion of the one or more operations within an instruction associated with the identifier to avoid a detected data hazard associated with a subsequent instruction to be executed, wherein the detected data hazard is to be avoided via a resolution of a data dependency on the operation of the one or more instructions having the data dependents and the identifier is to indicate a non-deterministic latency to resolve a data dependency.
2. The graphics processor as in claim 1 , wherein the hardware includes a hardware scheduler to schedule the decoded instruction.
3. The graphics processor as in claim 1 , wherein to execute the decoded instruction, the hardware is to configure the graphics processing engine to monitor execution of the instruction associated with an identifier of the one or more identifiers.
4. The graphics processor as in claim 3 , wherein to execute the decoded instruction, the graphics processing engine is to enable completion of the decoded instruction in response to a completion of a specified read or write operation of the instruction associated with the identifier.
5. The graphics processor as in claim 3 , wherein to execute the decoded instruction, the graphics processing engine is to enable completion of the decoded instruction in response to a completion of a read or write associated with a specified register of the instruction associated with the identifier.
6. The graphics processor as in claim 1 , wherein the instruction decoder is further to decode multiple identifiers to identify multiple instructions and the decoded instruction is to cause the graphics processing engine to block the completion of the decoded instruction until completion of an identified operation of the multiple instructions.
7. The graphics processor as in claim 6 , wherein the identified operation of the multiple instructions includes a write operation associated with each of the multiple instructions.
8. The graphics processor as in claim 6 , wherein the identified operation of the multiple instructions includes a read operation associated with each of the multiple instructions.
9. A method of managing data dependencies for program code to be executed by a general-purpose graphics processing unit (GPGPU), the method comprising:
loading program code to compile for execution on the GPGPU;
compiling the program code into at least an intermediate representation of compiled program code;
analyze register and memory usage of instructions in compiled program code;
determine a set of compiled instructions having a data dependency on other compiled instructions in the program code; and
for each instruction in the set of compiled instructions having the data dependency, encode scoreboard information into metadata for a compiled instruction, the scoreboard information to identify one or more data dependencies for the instruction, wherein the scoreboard information indicates a non-deterministic latency to resolve a data dependency.
10. The method as in claim 9 , wherein the scoreboard information additionally indicates a deterministic latency between dependent instructions.
11. The method as in claim 10 , wherein the scoreboard information indicates a distance between a first instruction and a second instruction, the second instruction dependent upon output of the first instruction.
12. The method as in claim 11 , wherein the distance is associated with a count of instructions between the first instruction and the second instruction.
13. The method as in claim 12 , wherein the data dependency is associated with register usage of the first instruction and the second instruction.
14. The method as in claim 9 , wherein metadata for the compiled instruction is appended to the compiled instruction.
15. The method as in claim 14 , wherein the scoreboard information indicates a scoreboard identifier to identify a first instruction, wherein a second instruction is dependent on a memory operation associated with the first instruction.
16. The method as in claim 15 , wherein the first instruction is executable out-of-order.
17. The method as in claim 16 , wherein the scoreboard information indicates a scoreboard identifier of a first instruction, wherein a second instruction is dependent on output of the first instruction, and the scoreboard information additionally includes a distance associated with a count of instructions between a third instruction and the second instruction, wherein the second instruction is additionally dependent upon output of the third instruction.
18. A non-transitory machine readable medium storing instructions which, when executed by one or more processors, cause the one or more processors to perform operations comprising:
loading program code to be compiled for execution on a graphics processor;
determining that a first instruction has a data dependency upon multiple instructions;
encoding metadata to identify a first data dependency into the first instruction, wherein the metadata includes scoreboard information that indicates a non-deterministic latency to resolve the first data dependency; and
inserting a second instruction to block execution of the first instruction until remaining data dependencies for the first instruction are resolved.
19. The non-transitory machine readable medium as in claim 18 , wherein the metadata to identify the first data dependency includes a count of instructions between the first instruction and a third instruction, the first instruction dependent upon an operation of the third instruction.
20. The non-transitory machine readable medium as in claim 18 , the operations additionally comprising:
assigning an identifier to each instruction in the program code upon which the first instruction depends, wherein the metadata to identify the first data dependency includes the identifier for a fourth instruction, the first instruction additionally dependent upon an operation of the fourth instruction.