Patent Publication Number: US-9904550-B2

Title: Methods for combining instructions and apparatuses having multiple data pipes

Description:
CROSS REFERENCE TO RELATED APPLICATIONS 
     This application claims the benefit of China Patent Application No. 201510521991.2, filed on Aug. 24, 2015, the entirety of which is incorporated by reference herein. 
     BACKGROUND 
     Technical Field 
     The present invention relates to graphics processing, and in particular, it relates to methods for combining instructions and apparatuses having multiple data pipes. 
     Description of the Related Art 
     The GPU (Graphics Processing Unit) architecture typically has hundreds of basic shader processing units, referred to as SPs (Stream Processors). Each SP may deal with one SIMD (Single Instruction Multiple Data) thread of one instruction per cycle, and then switch into another SIMD thread at the next cycle. The performance of GPU is affected by two important factors: the total amount of SPs and the capacities of one SP. Thus, methods for combining instructions and apparatuses having multiple data pipes are introduced to improve the capacities of one SP. 
     BRIEF SUMMARY 
     An embodiment of a method for combining instructions, performed by a compiler, contains at least the following steps. First instructions are obtained, where each performs one of a calculation operation, a comparison operation, a logic operation, a selection operation, a branching operation, a LD/ST (Load/Store) operation, a SMP (sampling) operation and a complicated mathematics operation. The first instructions are combined as one combined instruction according to data dependencies between the first instructions. The combined instruction is sent to a SP (Stream Processor). 
     An embodiment of an apparatus having multiple data pipes is introduced, contains at least a DF (Data Fetch) unit, a bypass-pipe and a main-pipe. The bypass-pipe is coupled to a CR (Common Register), a CB (Constant Buffer) and the DF unit. The main-pipe, coupled to the DF unit and the bypass-pipe, comprises an ALG (Algorithm) unit, a comparison/logic unit and a post-PROC (Process) unit. The ALG, comparison/logic and post-PROC units are coupled in series and each of the ALG, comparison/logic and post-PROC units is coupled to the bypass-pipe. 
     A detailed description is given in the following embodiments with reference to the accompanying drawings. 
    
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
       The present invention can be fully understood by reading the subsequent detailed description and examples with references made to the accompanying drawings, wherein: 
         FIG. 1  is the system architecture of a 3D (three-dimensional) graphics processing apparatus according to an embodiment of the invention; 
         FIG. 2  is a flowchart illustrating a method for combining instructions according to an embodiment of the invention; 
         FIGS. 3A and 3B  illustrate the system architecture of a 3D graphics processing apparatus according to an embodiment of the invention; 
         FIG. 4  is a flowchart illustrating a method for combining instructions according to an embodiment of the invention; and 
         FIG. 5  illustrates the system architecture of a 3D graphics processing apparatus according to an embodiment of the invention. 
     
    
    
     DETAILED DESCRIPTION 
     The following description is of the best-contemplated mode of carrying out the invention. This description is made for the purpose of illustrating the general principles of the invention and should not be taken in a limiting sense. The scope of the invention is best determined by reference to the appended claims. 
     The present invention will be described with respect to particular embodiments and with reference to certain drawings, but the invention is not limited thereto and is only limited by the claims. It will be further understood that the terms “comprises,” “comprising,” “includes” and/or “including,” when used herein, specify the presence of stated features, integers, steps, operations, elements, and/or components, but do not preclude the presence or addition of one or more other features, integers, steps, operations, elements, components, and/or groups thereof. 
     Use of ordinal terms such as “first”, “second”, “third”, etc., in the claims to modify a claim element does not by itself connote any priority, precedence, or order of one claim element over another or the temporal order in which acts of a method are performed, but are used merely as labels to distinguish one claim element having a certain name from another element having the same name (but for use of the ordinal term) to distinguish the claim elements. 
     The conventional SP (Stream Processor) executes simple operations, such as Algorithm, Compare, Logic, Selection, Branch etc. But a lot of data dependencies exist among adjacent instructions in one shader, so the SP has to read or write CR (common registers) frequently. The data dependencies may consume the CR bandwidth greatly and produce bottlenecks. In addition, the CR RAW (Read after write) issue may arise, decreasing the performance of the instruction execution. Shaders often use move instructions to initialize CRs, which requires the SP to pass data or constants from one CR or CB (Constant Buffer) to another. For a post-processing operation, such as an LD/ST (load/store) unit for data access, an SMP (sampling) unit for texture sampling, an SFU (Special Function unit), etc., the SP is responsible for reading one or more source values from CRs or CBs, and then passing them on to corresponding post-processing units. In such cases, it is not necessary to walk data or constants through algorithm execution, leading to wasting a certain level of SP capacity. A novel architecture with two data paths in one SP is introduced to improve SP performance. The first path may be referred to as a main-pipe with Algorithm, Compare, Logic, Selection and Branch operations, while the second path may be referred to as a bypass-pipe for a data- or constant-reading from one CR or CB and a passing to another CR or one post-processing unit. 
       FIG. 1  is the system architecture of a 3D (three-dimensional) graphics processing apparatus according to an embodiment of the invention. An SP executes instructions by using two pipes: the main-pipe; and the bypass-pipe. The main-pipe may contain three stages in order: the ALG (Algorithm) stage; the Post-LGC (Logic) stage including the Comparison and/or Logic operations; and the Post-PROC (Process) stage including the selection, branching and/or result WB (Write Back) operations. Results of one stage may be carried to the next stage. Final results may be stored in CRs or output to the post-processing unit. Specifically, the ID (Instruction Decode) unit  120  decodes the instruction request  110  sent from the compiler, and informs the relevant devices of the CR address  121  and/or the CB address  123  for data or constants to be obtained. The ID unit  120  may obtain Opcode (Operation Code) from the instruction request  110 . The DF (Data Fetch) unit  130  obtains data  133  stored at the CR address  121  and/or constants  135  stored at CB address  123 , and if required, inform the relevant devices of the CR address  131 , to which data is to be written back. The obtained data  133  and/or constants  135  may be referred to as operands. The ALG unit  140  performs a calculation operation on the obtained data. The calculation operations may include addition, subtraction, multiplication, division, left shift, right shift, and the like. The comparison/logic unit  150  may perform the comparison or logic operation according to the results generated by the ALG unit  140 . The comparison operations may include maximum, minimum, comparison, and the like. The logic operations may include AND, OR, NOT, NOR, XOR, and the like. The Post-PROC unit  160  may write the calculated data back to the CB or send the calculated data to one of the LD/ST unit  171 , the SMP unit  173  and the SFU  175  according to the result generated by the comparison/logic unit  150 . The SFU  175  implements complicated mathematics operations, such as SIN, COS, SQRT, etc. The bypass-pipe may include the bypass unit  180  sending data or a constant  181  from one CR or CB to another CR or the Post-PROC unit  160 . 
     Instructions used in the compiler may be classified into three kinds: main-pipe; bypass-pipe; and post-process-unit. The main-pipe instructions are used in the ALG, Post-LGC and Post-PROC stages. The ALG stage may use the following ALG instructions: FMAD, FADD, FMUL, IMUL24, IMUL16, IADD, SHL, SHR, FRC, FMOV, IMUL32I, IMUL24I, IADDI, IMAXI, IMINI, SHLI, SHRI, etc. The Post-LGC stage may use CMP/LGC (Comparison/Logic) instructions, such as IMAX, IMIN, FCMP, ICMP, IMAXI, IMINI, NOR, AND, OR, XOR, ICMPI, NORI, ANDI, ORI, XORI, etc. The Post-PROC stage may use SEL/Branch instruction, such as SEL, B, BL, IFANY, IFALL, etc. The post-processing-unit instructions are used in the LD/ST unit  171 , the SMP unit  173  and SFU  175 . The LD/ST unit  171  may perform the loading and storing instructions, such as LDU, STU, REDU, LDT, STT, REDUT, GLD, GST, GREDU, etc. The SMP unit  173  may perform the texture sampling instructions, such as SAMPLE, SAMPLE_B, SAMPLE_L, SAMPLE_C, SAMPLE_D, SAMPLE_GTH, SAMPLE_FTH, etc. The SFU  175  may perform the mathematics computation instructions, such as RCP, RSQ, LOG, EXP, SIN, COS, SQRT, etc. The bypass-pipe instructions may contain moving instructions, such as MOV, MOVIMM, etc. 
     With the above architecture, the compiler may combine several main-pipe instructions and the post-processing-unit instructions as one according to the data dependencies between the instructions, referred to as the static combination.  FIG. 2  is a flowchart illustrating a method for combining instructions according to an embodiment of the invention. The compiler may obtain several main-pipe instructions, and if required, one post-processing-unit instruction (step S 210 ), combine the obtained instructions as one combined instruction according to the data dependencies between the obtained instructions (step S 230 ) and send the combined instruction to the ID unit  120  (step S 250 ). In step S 230 , the compiler may perform the static combination according to the following rules: 
     ALG+CMP+SEL; 
     ALG+CMP+SEL+SFU/LS/SMP; 
     ALG+CMP+Branch; 
     ALG+LGC+SEL; 
     ALG+LGC+SEL+SFU/LS/SMP; or 
     ALG+LGC+Branch. 
     ALG indicates calculation instructions, CMP indicates comparison instructions, LGC indicates logic instructions, SEL indicates selection instructions, Branch indicates branching instructions, SFU indicates mathematics computation instructions, LS indicates Load/Store instructions and SMP indicates sampling instructions. An example is introduced to explain the static combination, where exemplary pseudo code is as follows: 
                                            x=a+b;           if (x&gt;c)           {              x=c;           }                        
The compiler performs the static combination to the pseudo code and translates it into the following machine code:
 
                                                        FADD   SFWD,   R4,   R8           +FCMP_GT   P1,   R5   SFWD           +SEL   R0,   P1,   SFWD,  R5                        
First machine code instructs to add the value of CR R 8  to the value of CR R 4  (that is, the values of variables b and a), and send the result to the next stage, in which “SFWD” indicates a passing of the result (that is, the value of variable x) to the next stage. Second machine code instructs to compare the value of CR R 5  (that is, the value of variable c) with the value received from the prior stage (that is, the value of variable x), in which “+” indicates that this instruction is combined with the previous one and “SFWD” indicates a reception of the result from the prior stage. Third machine code instructs to write the value received from the prior stage (that is, the value of variable x) or the value of CR R 5  (that is, the value of variable c) into the CR R according to the flag P 1 , in which “+” indicates that this instruction is combined with the previous one. If the flag P 1  is “1”, the value of CR R 5  (that is, the value of variable c) is written into the CR R 0 . Otherwise, the value received from the prior stage (that is, the value of variable x) is written into the CR R 0 .
 
     The computation units of the architecture may be modified to enable the GPU to execute the combined instructions.  FIGS. 3A and 3B  illustrate the system architecture of a 3D graphics processing apparatus according to an embodiment of the invention. The adder  310  obtains the value of CR R 4  and the value of CR R 8  (that is, the values of variables b and a) through the pre-ALU (Arithmetic Logic Unit) and sends the calculation result to the comparator  330  through the normalizer and the formatter. The comparator  330  receives the result generated by the ALG unit  140  (the prior stage), obtains the value of CR R 5  (that is, the value of variable c) through the bypass unit  180 , and compares the two. The selection unit  350  writes one of the result  353  (that is, the value of variable x) generated by the adder  310  and the value  355  of CR R 5  received from the bypass unit  180  back to the CR R 0  according to the comparison result (the output from the prior stage)  351 . In order to execute the combined instruction, the computation units of the ALG unit  140  are coupled to the DF unit  130  and the bypass unit  180  for obtaining operands, and the computation units of the comparison/logic unit  150  and the Post-PROC unit  160 , such as the comparator  330  and the selection unit  350 , for outputting the results to the next stage. The computation units of the comparison/logic unit  150  are coupled to the ALG unit  140  and the bypass unit  180  for obtaining operands, and the computation units of the Post-PROC unit  160 , such as the selection unit  350 , for outputting the results to the next stage. The computation units of the Post-PROC unit  160  are coupled to the ALG unit  140 , the comparison/logic unit  150  and the bypass unit  180  for obtaining operands, and coupled to the CRs, the LD/ST unit  171 , the SMP unit  173  and the SFU  175  through the selection unit  350  for writing back the data to the CRs or outputting the results to the post-processing units. In addition to the selection unit  350 , the Post-PROC unit  160  further includes a branching unit and a determination unit for determining whether to write back the results to the CRs. 
     With the above architecture, the compiler may combine the bypass-pipe instruction and the main-pipe instructions and/or the post-processing-unit instructions as one, referred to as the bypassed combination.  FIG. 4  is a flowchart illustrating a method for combining instructions according to an embodiment of the invention. The compiler may obtain several instructions (step S 410 ), combine one bypass-pipe instruction and at least one of the main-pipe instruction and the post-processing-unit instruction as one combined instruction (step S 430 ) and send the combined instruction to the ID unit  120  (step S 450 ). In step S 430 , the combination order for the main-pipe instructions may follow the aforementioned rules. In other words, step S 430  may be considered that the combined result for several main-pipe instructions is combined with one bypass-pipe instruction and/or one post-processing-unit instruction. An example is introduced to explain the bypassed combination, where machine code is as follows: 
                                                    MOV   R0,   R4           +FADD   SFWD,   .R4,  R8           RCP   R7,   SFWD                        
First machine code instructs to store the value of CR R 4  in the CR R 0 . Second machine code instructs to add the value of CR R 4  to the value of CR R 8 , and send the result to the next stage, in which “+” indicates that this instruction is combined with the previous one and “SFWD” indicates a passing of the result to the next stage. Third machine code instructs to obtain a reciprocal of the value received from the prior stage and stores the reciprocal in the CR R 7 , in which “SFWD” indicates a reception of the result from the prior stage.
 
       FIG. 5  illustrates the system architecture of a 3D graphics processing apparatus according to an embodiment of the invention. The bypass unit  180  receives the instruction of the DF unit  130  to read the value of the CR R 4  and write it in the CR R 0 . At the same time, the adder  510  obtains the value of CR R 4  and the value of CR R 8  through the pre-ALU and sends the calculation result to the SFU  175  through the normalizer and the formatter. The SFU  175  calculates the reciprocal of the received value and writes the reciprocal in the CR R 7 . The performance of one SP can be improved because the operations of the main-pipe instruction and the post-processing-unit instruction are performed in parallel of the operation of the bypass-pipe instruction. 
     Refer to  FIGS. 3 and 5 . To sum up, the ALG, comparison/logic and Post-PROC units are coupled in series and each of the ALG, comparison/logic and Post-PROC units is coupled to the bypass unit so as to execute the combined instruction. Specifically, the first computation unit of the ALG unit  140 , such as the adder, the multiplier, the divider, etc., is coupled to the bypass unit  180  (that is, the bypass-pipe) and the DF unit  130  for obtaining the operands from the bypass unit  180  and/or the DF unit  130 . The second computation unit of the comparison/logic unit  150 , such as the comparator, any of wide range of logical gates, etc., is coupled to the bypass unit  180  and the output of the first computation unit for obtaining operands from the bypass unit  180  and/or the output of the first computation unit. The third computation unit of the Post-PROC unit  160 , such as the selection unit, the branching unit, etc., is coupled to the bypass unit  180 , the output of the first computation unit and the output of the second computation unit for obtaining operands from the bypass unit  180 , the output of the first computation unit and the output of the second computation unit. The third computation unit is further coupled to the LD/ST unit  171 , the SMP unit  173  and the SFU  175  for outputting the operation results to the post-processing units. 
     Although the embodiments have been described in  FIGS. 1, 3 and 5  as having specific elements, it should be noted that additional elements may be included to achieve better performance without departing from the spirit of the invention. While the process flows described in  FIGS. 2 and 4  include a number of operations that appear to occur in a specific order, it should be apparent that these processes can include more or fewer operations, which can be executed serially or in parallel, e.g., using parallel processors or a multi-threading environment. 
     While the invention has been described by way of example and in terms of the preferred embodiments, it is to be understood that the invention is not limited to the disclosed embodiments. On the contrary, it is intended to cover various modifications and similar arrangements (as would be apparent to those skilled in the art). Therefore, the scope of the appended claims should be accorded the broadest interpretation so as to encompass all such modifications and similar arrangements.