Allocation of resources of a pipelined processor by clock phase for parallel execution of dependent processes
CROSS REFERENCE TO RELATED APPLICATION 
     This is a continuation of application Ser. No. 07/669,824 filed on Mar. 15, 1991, now abandoned. 
    
    
     BACKGROUND OF THE INVENTION 
     1. Field of the Invention 
     The present invention relates to a technique for dynamic scheduling of a pipelined processor for parallel execution of multiple processes, and more particularly, to a pipelined processing system which executes multiple processes in parallel and arbitrates access to shared resources on a phase of the system clock so as to eliminate the need for complex resource allocation algorithms. 
     2. Description of the Prior Art 
     Since the processing speed and hence performance of data processing systems doubles every year or so, engineers are constantly searching for new ways to improve the processing speeds of their systems in order to remain competitive. A typical way to improve processing speed and hence to shorten execution time has been to utilize multiprocessing techniques in which a plurality of processors are operated in parallel. For example, several general purpose processors may be loosely coupled in parallel such that jobs which are to be performed by the respective processors are assigned on a process basis and executed in parallel. An example of a general purpose machine having loosely coupled parallel processors which process data in this manner is the VAX 785. Even faster execution may be obtained by placing several special purpose processors in parallel. Special purpose processors arranged in this manner have improved efficiency because they may be tightly coupled to one another to perform a limited special purpose Job such as geometric transformation of input coordinates or polygon rendering in a computer graphics system. Parallel special purpose processors may also be interleaved for pipelined processing applications as described by Hannah in U.S. Pat. No. 4,789,927 issued Dec. 6, 1988. 
     Another technique for providing faster execution in a data processing system is to speed up the execution on each processor. In other words, a typical way to improve the processing speed is to increase the frequency of the system clock. Increasing the frequency of the system clock improves performance nearly linearly for typical data processing systems by reducing the cycle time. However, data processing systems can only function as rapidly as their hardware and control process permits, and, as a result, there are limits as to how much the frequency of the system clock may be increased. 
     Yet another technique for improving execution time in a data processing system is pipelining. Pipelining is an implementation technique in which multiple instructions are simultaneously overlapped in execution. Each step in the pipeline completes a part of the instruction by breaking the work to be done in an instruction into smaller pieces and processing each of those pieces, whereby processing of each instruction piece takes a fraction of the time as processing the entire instruction. Each of these steps is called a pipe stage or pipe segment and is implemented on what is referred to herein as a &#34;pipelined processing circuit&#34;. The pipelined processing circuits are connected one to the next to form a pipeline in which the instructions enter at one end, are processed through the respective pipelined processing circuits, and exit at the other end. As known to those skilled in the art, if the pipelined processing circuits process the data at approximately the same speed, the speedup from such pipelining approaches the number of pipe stages. For this reason, pipelining is the key implementation technique used to make fast central processing units (CPUs) and also is the subject of the present invention. 
     The throughput of a pipeline is determined by how often an instruction exits the pipeline. Because the pipe stages are connected together, all the stages must be ready to proceed at the same time. The time required between moving an instruction a single step down the pipeline is referred to as a machine cycle, where the length of a machine cycle is determined by the time required for the slowest pipe stage because all stages proceed at the same time. The machine cycle is typically one clock cycle, but may be two or more. The clock may also have multiple phases. Moreover, by making the pipe stages approximately equal in length, pipelining yields a reduction in the average execution time per instruction by decreasing the clock cycle time of the pipelined machine. Thus, pipelines can be used to both decrease the clock cycle and to maintain a low CPI. 
     Execution time in a pipelined system thus may be reduced if the pipe stages are made substantially equal in length and the frequency of the system clock is maximized. However, in a pipelined processing system the true measure of the effectiveness of increasing the frequency of the system clock is the number of clock cycles per instruction (CPI) necessary to process a particular instruction. As will be described below, several techniques have been proposed for minimizing the CPI of a pipelined processing system so as to improve the processing efficiency of the system. Such techniques employ different combinations of parallel processing and fast processor clocks. However, such techniques have typically been based on the needs of a general purpose processor and have not taken advantage of the characteristics of special purpose processors. 
     Pipelined architectures introduce several problems which must be overcome by a designer if the processing efficiency of a processing system is to be actually improved by pipelining. For example, there are situations, called hazards, that prevent the next instruction in the instruction stream from executing during its designated clock cycle. Hazards reduce the performance from the ideal speedup gained by pipelining and may be classified as one of three types: Structural, Data and Control hazards. Structural hazards arise from resource conflicts when the underlying hardware cannot support all possible combinations of instructions in simultaneous overlapped execution, while Data hazards arise when an instruction depends on the results of a previous instruction in a way that it is exposed by the overlapping of instructions in the pipeline. Control hazards arise from the pipelining of branches and other instructions that change the program counter. Such hazards prevent instructions from executing in their designated clock cycles because they make it necessary to stall the pipeline to eliminate the hazard. Such stalls cause a significant adverse effect on performance, for in a pipelined machine there are multiple instructions under execution at once. In other words, a stall in a pipelined machine often requires that some instructions be allowed to proceed, while others are delayed. Typically, when an instruction is stalled, all instructions later in the pipeline than the stalled instruction are also stalled. On the other hand, instructions earlier than the stalled instruction can continue, but no new instructions are fetched during the stall. The instructions thus may not complete in the desired order, thereby creating further problems. Accordingly, much design effort in a pipelined processing system is used to prevent stalls by preventing such hazards or at least by dealing with these hazards as they develop. 
     As known to those skilled in the art, when a processing system is pipelined, the overlapped execution of instructions requires pipelining of functional units and duplication of resources to allow all possible combinations of instructions in the pipeline. As noted above, a structural hazard results if some combination of instructions cannot be accommodated due to resource conflicts. The most common instances of structural hazards arise when some functional unit is not fully pipelined. Then a sequence of instructions that all use that functional unit cannot be sequentially initiated in the pipeline. Another common way that structural hazards appear is when some resource has not been duplicated enough to allow all combinations of instructions in the pipeline to execute. When a sequence of instructions encounters a structural hazard, the pipeline will stall one of the instructions until the required unit is available. Unfortunately, red, oval of all such structural hazards is unrealistic, for to do so would substantially increase the cost of the processing system and increase the latency of the pipeline. Accordingly, the typical approach has been to account for all structural hazards and take the necessary steps to minimize their effects. Such techniques will be described in more detail below. 
     As noted above, a major effect of pipelining is to change the relative timing of instructions by overlapping their execution. However, by overlapping the execution of instructions in this manner, data and control hazards are introduced. Data hazards occur when the order of access to operands is changed by the pipeline versus the normal order encountered by sequentially executing instructions. For example, if a second instruction of two adjacent pipelined instructions has a source that is the destination of the first instruction, precautions must be taken to ensure that the second instruction does not access the destination of the first instruction before it has been updated. Unless precautions are taken to prevent such data hazards, the second instruction will read the wrong value and try to use it. Such unpredictable behavior is of course unacceptable. 
     Generally, a data hazard is created whenever there is a dependence between instructions which are close enough that the overlap caused by pipelining would change the order of access to an operand. For example, in the special case of a rendering processor in a computer graphics system, the vertex data and rendering command can create data hazards. Data hazards also may result when a pair of instructions create a dependence by writing and reading the same memory location. For example, cache misses could cause the memory references to get out of order if the processor were allowed to continue working on later instructions while an earlier instruction that missed the cache was accessing memory. Accordingly, when a cache miss is encountered, the entire pipeline must be stalled, effectively making the instruction that contained the miss run for multiple clock cycles. However, stalls may be partially avoided by rearranging the code sequence to eliminate the hazard causing the stall. Such techniques are called pipelined scheduling or instruction scheduling and have been widely used by those skilled in the art. Such pipeline scheduling typically is quite complex but has been effectively used to keep the CPI on the order of one. 
     Control hazards can cause an even greater performance loss for a pipeline than data hazards. For example, when a branch is executed, it may or may not change the program counter to something other than its current value plus the length of an instruction. If an instruction is a taken branch, then the program counter is normally not changed until the end of the memory cycle, after the completion of the address calculation and comparison. This means stalling the pipeline for the instruction decode, the execute and the memory access cycles, at the end of which the new program counter is known and the proper instruction can be fetched. This effect is called a control or branch hazard and can be addressed by a technique known by those skilled in the art as branch prediction. Although branch prediction is quite simple, it does not effectively reduce the CPI to less than one. 
     The above and other problems and features of pipelining have been discussed in detail by Patterson and Hennessy in Chapter 6 of a text entitled Computer Architecture: A Quantitative Approach, Morgan Kaufmann Publishers, San Mateo, Calif., 1990, pp. 250-349, the contents of which are incorporated herein by reference. For example, Patterson et al. teach that data dependencies may be minimized by using software to schedule the instructions to minimize stalls. Such an approach is called static scheduling. On the other hand, a technique known as dynamic scheduling may be used, whereby the hardware rearranges the instruction execution to reduce the stalls. Unfortunately, the advantages which are gained by dynamic scheduling have heretofore come at a significant cost in increased hardware complexity. 
     For example, scoreboarding is a sophisticated prior art technique for dynamically scheduling around hazards by allowing instructions to execute out of order when there are sufficient resources and no data dependencies. In particular, a scoreboard is used to separate the process of issuing an instruction into two parts, namely, checking the structural hazards and waiting for the absence of a data hazard. Structural hazards can be checked when an instruction is issued; however, if the instructions are to begin execution as soon their data operands are available, the pipeline will have to perform out of order execution. Scoreboarding makes this possible. 
     The goal of a scoreboard is to maintain an execution rate of one instruction per clock cycle when there are no structural hazards by executing an instruction as early as possible. Thus, when an instruction at the front of an input queue is stalled, other instructions can be issued and executed if they do not depend on any active or stalled instruction. The scoreboard takes full responsibility for instruction issue and execution, including all hazard detection. Taking advantage of out of order execution requires multiple instructions to be in their execution stage simultaneously. This can be achieved with either multiple functional units or with pipelined functional units. Accordingly, a scoreboard acts as a means for resource allocation which checks for hazards and then allocates the instructions accordingly. 
     FIG. 1 illustrates a pipelined processing system utilizing a scoreboard. As shown, a plurality of registers 100 are provided which are accessed by respective pipelined processing circuits 102-108 to perform pipelined processing functions on the data stored therein. A scoreboard 110 is provided for receiving every instruction and constructing a picture of the data dependencies of the respective instructions. This picture is then used by scoreboard 110 to determine when an input instruction can read its operands and begin execution. If scoreboard 110 decides the instruction cannot execute immediately, it monitors every change in the hardware and decides when the instruction can execute. Scoreboard 110 also controls when an instruction can write its result into its destination register. Thus, all hazard detection and resolution is centralized in the scoreboard 110. 
     Scoreboard 110 also controls the instruction progression from one step to the next by communicating with the functional units 102-108. However, since there is only a limited number of source operands and result buses to the registers 100, scoreboard 110 must guarantee that the functional units allowed to proceed do not require more than the number of data busses available. In other words, the data busses are treated by the scoreboard as resources which must be allocated. This added complexity often causes the scoreboard 110 to have about as much logic as one of the functional units and, on average, about four times as many data busses as would be required if the pipeline only executed instructions in order. Such complexity is undesirable, and it is desired that relatively simple techniques be developed for efficient pipelined processing. In particular, an alternative to the use of scoreboards for special purpose pipelined processing systems is desired. 
     In addition to branch prediction and static and dynamic pipeline scheduling, one other prior art technique for improving execution on a single processor merits discussion here. A technique known as superscalar allows the CPI to be decreased to less than one. Since the CPI cannot be reduced below one if only one instruction is issued every clock cycle, superscalar is a technique whereby multiple instructions are issued in a clock cycle for parallel execution. This allows the instruction execution rate to exceed the clock rate. Typical superscalar pipelined processing systems issue a few instructions in a single clock cycle. However, if the instructions in the instruction stream are dependent or do not meet certain criteria, only the first instruction in the sequence will be issued since a hazard has been detected. 
     Superscalar systems are also extremely complicated and require additional hardware. However, the need for additional hardware may be minimized if the instructions use different register sets and different functional units. Moreover, any contentions may be treated as structural hazards and overcome by delaying the issuance of one of the instructions which causes the contention. The contention can also be eliminated by adding several additional bypass paths. However, these solutions make the superscalar system just that much more complicated. 
     Superscalar pipelines also suffer from other problems which limit their effectiveness. For example, in a superscalar pipeline the result of a load instruction cannot be used on the same clock cycle or on the next clock cycle. As a result, the next three instructions cannot use the load result without stalling. Accordingly, to effectively exploit the parallelism available in a superscalar pipeline, more ambitious compiler-scheduling or hardware implemented scoreboarding techniques, as well as more complex instruction decoding, must be implemented. Such techniques unduly complicate the processing and are generally undesirable except in the most sophisticated general purpose pipelined processing systems. 
     Accordingly, although branch prediction, pipeline scheduling and superscalar techniques as described above have effectively lowered the CPI in prior art pipelined processing systems, this improvement has come with great costs in hardware complexity. Moreover, such techniques are generally based on the needs of a general purpose machine. Thus, in order to lower the CPI for a special purpose pipelined processing system, such as a computer graphics system, other techniques for reducing the CPI are desired which have the benefits of the systems described above yet are much simpler and hence easier to implement in a special purpose pipelined architecture. The present invention relates to such a technique. 
     SUMMARY OF THE INVENTION 
     The above-mentioned shortcomings in the prior art have been met in accordance with the present invention by developing a technique for dynamic scheduling of a pipelined processor for parallel execution of multiple processes. The technique of the invention is quite straightforward and eliminates the need for complex resource allocation algorithms of the type used in prior art pipelined processing systems of the type described above. In particular, the present invention allocates critical resources shared by multiple processes by synchronizing the processes to the respective phases of the system clock. As used herein, a critical resource is a resource of the pipeline which must be accessed by a process to continue its command execution and to prevent pipeline stalls. In other words, certain input commands are given access to shared critical resources only during particular phases of the system clock. By so arbitrating access to shared critical resources based upon the phase of the system clock, instructions need not be executed in sequential order so long as there are no data dependencies between the respective instructions. Moreover, such an arrangement effectively implies a scoreboard of the type used in the prior art from the hardware configuration of the system, whereby resource allocation is inherent in the design. In particular, there is no need to check for a structural hazard or wait for the absence of a data hazard since the respective processes share critical resources in a time-division multiplexed manner. The present invention thus resolves, without adding undue complexity, the resource allocation problems which have heretofore limited the performance of pipelined processing systems. 
     In particular, the present invention relates to a pipelined processing system comprising a data pipeline having at least one pipelined processing circuit and a system clock for applying clocking signals to the at least one pipelined processing circuit of the data pipeline. Pipeline control means are also provided for controlling the access to critical resources within the data pipeline. Such pipeline control means in accordance with a preferred embodiment of the invention comprises at least two control processes synchronized to respective predetermined phases of the system clock such that each control process controls the access to critical resources within the data pipeline during its predetermined phase of the system clock and does not control the access to critical resources within the data pipeline during other phases of the system clock. Since each control process is only given access to critical resources during its predetermined phase of the system clock, structural, data and control hazards are minimized. Moreover, since the control processes allow the pipelined processing circuits to operate in parallel on different phases of the clock, system throughput is increased and the CPI reduced. Such an arrangement has been found to almost double performance with virtually no additional hardware. 
     Since the presence of data dependencies can be predetermined in a special purpose processing system, the present invention is particularly useful in pipelined special purpose processing systems such as pipelined rendering circuitry of computer graphics systems. However, the technique of the invention may be readily applied to general purpose processing systems in ways which will be readily apparent to those skilled in the art. 
    
    
     BRIEF DESCRIPTION OF THE DRAWINGS 
     These and other objects and advantages of the invention will become more apparent and more readily appreciated from the following detailed description of the presently preferred exemplary embodiment of the invention taken in conjunction with the accompanying drawings of which: 
     FIG. 1 illustrates a prior art pipelined processing system in which a scoreboard is used to allow pipeline instructions to execute out of order when there are sufficient resources and no data dependencies between respective instructions. 
     FIGS. 2(a)-(2j) respectively illustrate timing diagrams for use in describing the dynamic scheduling technique of the present invention. 
     FIG. 3 illustrates a preferred embodiment of the invention as implemented in a pixel processor of a pipelined computer graphics system. 
     FIGS. 4(a) and 4(b) respectively illustrate pipelined operation in accordance with a prior art pipelined processing technique without dynamic scheduling and the pipelined processing technique of the invention whereby pipeline stalls are prevented using dynamic scheduling based on the system clock. 
    
    
     DETAILED DESCRIPTION OF THE PRESENTLY PREFERRED EMBODIMENT 
     A system and method which affords the abovementioned and other beneficial features in accordance with a presently preferred exemplary embodiment of the invention will be described below with reference to FIGS. 2-4. Although the invention is described herein in conjunction with a pipelined pixel rendering system of a computer graphics system, and more particularly, in conjunction with a pipelined polygon scan line stepper (X-stepper) of the type described in related U.S. patent application Ser. No. 07/670,552, filed Mar. 15, 1991 (reference number 189339), the contents of which are hereby incorporated by reference, it will be appreciated by those of ordinary skill in the art that the principles of the invention may be applied to general and special purpose pipelined processing systems in other data processing environments as well. For example, the techniques of the invention may be readily applied to reduced instruction set computer (RISC) processors as well as pipelined supercomputer processors. Moreover, those skilled in the art will appreciate that the description given herein is for explanatory purposes only and is not intended in any way to limit the scope of invention. All questions regarding the scope of the invention may be resolved by referring to the appended claims. 
     Although not necessary to the invention, the preferred embodiment of the invention takes advantage of the fact that VLSI circuits may operate at frequencies substantially higher than that at which the input/output operations may be performed. In other words, while the frequency of the system clock is limited by the I/O capability of the system (due to propagation delays on the circuit board, clock skew, and the like), the frequencies used in the VLSI circuits need not be so limited. For example, in a preferred embodiment the data pipeline is synchronized to a system clock operating at 25 MHz, while the control system for the data pipeline is implemented in programmable logic arrays (PLAs) synchronized to a system clock operating at 50 MHz. Preferably, the 25 MHz clocks are derived from the 50 MHz clocks and are further synchronized to each other so that clock phases may be defined for arbitrating access to critical resources in accordance with the teachings of the invention. The general concept of using respective phases of the system clock to arbitrate access to shared resources will first be described conceptually with respect to FIGS. 2(a )-2(e). 
     FIG. 2(a) illustrates a 50 MHz signal which is applied to the control PLAs of the pipeline control system, while FIG. 2(b) illustrates a 25 MHz signal which is applied to the pipelined processing circuits in the data pipeline. As shown, these signals are synchronized to each other such that a complete cycle of the 50 MHz signal occurs during both the low and the high states of the 25 MHZ signal. For ease of description, the 25 MHz signal is defined as being in an even state when the output value is low and in an odd state when the output value is high. As will be described in detail below, these even and odd states are used to arbitrate access to shared resources between two control processes. However, one skilled in the art will appreciate from the following description that the technique of the invention can also be used on system clocks having three, four or more phases. Such an extension would merely require a modulo counter for counting the phases of the clock such that structural and data hazards can be avoided. The control processes would then operate during their assigned phase of the system clock. 
     Generally, the present invention utilizes a simplified dynamic scheduling technique based on the system clock phase to control access to critical resources of a data pipeline. A first control process controls access to critical resources of the data pipeline for the usual case. However, in accordance with the technique of the invention, the first process controls critical resources in the data pipeline only during an even (or odd) phase of the system clock and will not control the critical resources in the data pipeline during the odd (or even) phase of the system clock. Then, a second (parasitic) control process will be used to control the critical resources in the data pipeline only during the odd (or even) phase of the system clock, provided, however, that the pipeline instruction executed by the second process during the odd (or even) phase of the system clock has no data dependencies with the instruction being executed during the even (or odd) phase of the system clock by the first process. The second process thus can only process those instructions which do not have data dependencies with instructions being executed by the first process, while the first process can operate on all input instructions irrespective of the existence of the second process (albeit at a substantially reduced performance). 
     The control processes of the invention are basically responsible for allocating access to critical resources of the data pipeline in synchronization by generating &#34;advance pipe&#34; signals which instruct the pipelined processing circuit to advance to the next processing state. In accordance with the invention, the first process will produce &#34;advance even&#34; signals at the end of an even state (FIG. 2(d)) and &#34;advance odd&#34; signals at the end of an odd state (FIG. 2(e)). Accordingly, those resources controlled by the first process during the even state will be advanced at the end of the current even clock cycle, while those resources controlled by the first process during the odd state will be advanced at the end of the current odd clock cycle so long as those resources are not critical. The net result is that control of only the critical resources will be time-division multiplexed. 
     For a dual process control system, the system clock states are arranged into sets of two such that every even state will be followed by its odd state as is apparent from FIG. 2(b). Thus, although each control process is operated by a 50 MHz signal, each control process will only advance data using the critical resources during its assigned clock phase (odd or even) of the 25 MHz clock. 
     Several rules must be implemented for the system herein defined to avoid data hazards. For example, all conditional jumps in the control processes must enforce the even/odd rule set forth above. For example, this may be accomplished by specifying that conditional jumps are only from odd states to even states. Also, pipeline stalls should always stop the pipeline at the beginning of an even (or odd) state. Thus, when the pipeline restarts, the pipeline may be resynchronized by starting with the next even (or odd) state. FIG. 2(c) illustrates a pipelined stop which occurs, for example, when a particular instruction has encountered a cache miss. As shown, downstream circuitry is not advanced when the pipeline is stopped, and no further execution takes place until the first &#34;advance even&#34; state is received after the pipeline stop ends. However, as will be described below with respect to FIG. 2(j), the second control process continues to operate even when the pipeline is stopped during a pipeline stop. Such a feature is particularly advantageous when short vectors are being rendered, since short vectors generate numerous cache misses. 
     In addition, data busses similarly must be arbitrated as herein described in order to prevent data contention on the data busses. Accordingly, just as instructions inherently know that they can use critical resources because of the clock phase, the data processing circuits know that they have control of the data busses when they are instructed to pass data to the next pipe stage. As a result, complex resource allocation techniques such as scoreboarding are not required. 
     A preferred embodiment of the invention more specifically setting forth the advantages of the invention now will be described with respect to FIG. 3. 
     FIG. 3 schematically depicts a preferred embodiment of a pixel processor in a pipelined computer graphics system incorporating the dynamic scheduling technique of the invention. As shown, input data including pipeline instructions are received from a graphics processsor by an input block 300. Input block 300 connects the pixel processor of FIG. 3 to upstream components of the graphics processing system and preferably provides a &#34;handshake&#34; function for the input data. In other words, input block 300 stores the input data in registers and places the data on a data bus in blocks of predetermined sizes for passage to the downstream pipelined processing circuits of the pixel processor. As known to those skilled in the computer graphics art, the input instructions may include draw trapezoid commands or draw vector (rendering) commands, store vertex (setup) commands and the like. When input control PLA 302 detects that valid data has been received by input block 300, control process 1 of data pipeline control device 304 is informed via its line driver that valid input is available to be processed in the input block 300. Control process 1 of data pipeline control device 304 then instructs input block 300 to clock its input data through to command register 306, where the commands are issued and decoded under control of control process 1. Those skilled in the art will appreciate that since all input commands must be evaluated, command register 306 becomes a critical resource, for all decisions about execution of commands are made by control process 2 while control process 1 control rendering. As shown, control process 1 (which may be implemented via PLAs as shown below in the attached Appendix) communicates via the line drivers (output transistors) of data pipeline control device 304 to control the transfer and decoding of the commands in accordance with known techniques. 
     As noted above, the input commands may be draw trapezoid commands, draw vector commands, store vertex data commands and the like. For ease of description, it will be assumed that the input commands will be either store vertex data commands or rendering commands. As known to those skilled in the computer graphics art, the vertex data for the next primitive has no data dependency with the current rendering commands in progress. The rendering command, on the other hand, uses the vertex data of each input polygon to calculate the values of all pixels within the polygon having the indicated vertices and thus has numerous data dependencies. 
     The polygons to be rendered may come in many different sizes. For example, screen sized polygons can require over a million clock cycles to be used in the calculation of their display pixel values. Large polygons thus may cause the data pipeline to be stalled for many clock cycles. However, in the typical case the vertex commands take about as long to process as the rendering commands. Thus, on average, the two processes controlling the critical resources are about balanced so as to allow approximately a two times performance speedup. 
     The dynamic scheduling technique of the invention is thus advantageous in that it minimizes the adverse effects of the pipeline stalls by allowing subsequent commands, such as store vertex (setup) commands for the next polygon, to be processed during an opposite phase of the system clock. This allows the pipeline to be set up for the next polygon render while the current rendering step is performed, thereby improving processing efficiency. The processing improvement can best be appreciated by referring to FIGS. 4(a) and 4(b). 
     FIG. 4(a) illustrates the pipelined instruction sequence for rendering a polygon in accordance with prior art techniques. As shown, the vertices of the polygon to be rendered are read in and then rendered. The rendering instruction may execute for many clock cycles and cause a pipeline stall during which no other processing may take place. When the polygon is finally rendered, the vertices of the next polygon to be rendered are read in and the process repeated. As noted above, these pipeline stalls may cause significant adverse effects in processing efficiency. 
     By contrast, FIG. 4(b) illustrates the technique of the invention whereby a second control process is activated on opposite phases of the system clock to process the store vertex commands while the previous polygon is being rendered under control of the first control process. As shown, the effects of the pipeline stalls can be minimized by setting up the pipeline for processing of subsequent polygons as previous polygons are rendered. The technique for accomplishing this will be described in more detail by referring back to FIG. 3. 
     During normal operation of the pipeline circuit of FIG. 3, control process 1 examines each input instruction stored in command register 306 and instructs the downstream hardware such as vector/polygon stepper 308, address pipeline 310 and interpolator 312 to perform the necessary pipelined processing functions. In fact, so long as the input commands have data dependencies, the processing of the pipelined circuit of FIG. 3 proceeds as in the prior art system depicted in FIG. 4(a). However, if control process 1 is processing a render command and the next input command is a command, such as a store vertex command, which has no data dependencies with the current render commands, the benefits of the dynamic scheduling technique of the invention may be appreciated. 
     Accordingly, in the preferred embodiment of the invention, when input PLA 302 informs pipeline control circuit 304 that valid data has been received, control process 1 is started to handle the input commands. A source file listing of a PLA which performs the functions of control process 1 is attached below as an Appendix. Control process 1 is assigned an even (or odd) phase of the system clock and hence only controls access to critical resources such as command register 306 during the assigned clock phase. During the unassigned clock phase, access to the critical resources is not permitted. However, when a rendering command is recognized by control process 1, control process 2 is started and assigned an opposing phase of the clock for accessing critical resources. Control process 2 then reads the next instruction from the command register 306 to determine if the next instruction is one that can be processed while control process 1 controls the polygon render. The aforementioned Appendix also sets forth a preferred embodiment of PLA code for implementing control process 2. Control process 2 is shown in the Appendix as &#34;machine side door&#34;, and as shown therein it is a very small piece of code, much simpler than the aforementioned compiler-scheduling code or scoreboard hardware. 
     If control process 1 is still controlling a render and the next command is a command such as a draw trapezoid, that command is not processed by control process 2 because two renders may not proceed on the same pipelined processing circuits at the same time without causing structural and data hazards. The data pipeline thus remains stalled as in the FIG. 4(a) case. However, as just noted, if the next command does not have data dependencies with the rendering command, it may be processed and given access to the critical resources during the phases of the system clock assigned to control process 2. 
     Polygon rendering in accordance with the technique of the invention proceeds as follows. If the input command is a draw trapezoid command, control process 1 instructs vector/polygon stepper 308 to read in input edge data and the like from input block 300. Vector/Polygon stepper 308 is preferably of the type described in a paper by one of the present inventors entitled &#34;High Speed High Quality Antialiased Vector Generation&#34;, Computer Graphics, Volume 24, No. 4, August 1990, pp. 319-326. The calculated addresses (x,y) from Vector/Polygon stepper 308 are input into address pipe 310 and the perspective values are input into interpolator 312 (during the clock phase assigned to control process 1). Interpolator 312 calculates the pixel values based on the parameters stored in vertex register 314 when a vertex command is processed by control process 1 or control process 2. For example, such values may include red, green and blue values and a transparency value α for each vertex. Thus, the vertex color and transparency value and, if desired, the perspective scaling values for each pixel may be applied to the interpolator 312 for interpolation in accordance with techniques described, for example, in related U.S. patent application Ser. No. 07/493,189, filed by Swanson on Mar. 14, 1990. The interpolation techniques therein described are incorporated herein by reference. The scaled pixel parameters are then forwarded under control of interpolator PLA 316 to output formatter 318 where the scaled pixel parameters are associated with the corresponding coordinate values output form the address pipeline 310. The output of output formatter 318 is then sent to downstream hardware under control of output PLA 320 for further processing (such as dithering, gamma correction, windowing and the like) before ultimately being displayed on a display screen in accordance with known techniques. 
     While critical resources are being controlled by control process 1 during even (or odd) states of the system clock and control process 1 is processing a render command, control process 2 is activated during odd (or even) states of the system clock to check the next entry in the command register. If, for example, the next command is a store vertex command, control process 2 preprocesses this command, accessing critical resources during the odd (or even) states of the system clock, and stores the vertex data for the next polygon in the next vertex register 314b of vertex register 314. This process is repeated during the odd (or even) phases of the system clock until either all the vertex data has been stored in next vertex register 314b and no further commands may be preprocessed by control process 2, or the rendering of the previous polygon under control of control process 1 is completed. Once the rendering of the previous polygon has completed, the contents of the next vertex register 314b are input into the current vertex register 314a. As would be apparent to one skilled in the art, vertex register 314 may be implemented as a master/slave memory or a double buffer. The data pipeline is then ready for the next render without further delay. 
     When rendering is not being conducted, there is no address data to be sent from the vector/polygon stepper 308 to address pipeline 310. However, any time interpolation data is sent to interpolator 312, an indicator of some sort must be sent down the address pipeline 310 so that output formatter 318 knows that interpolated data will be coming through. In addition, the &#34;advance even&#34; time slot that advances the address pipeline 310 must also be used to send commands to the interpolator 312. In this manner, the addresses may be kept matched with the appropriate pixel data emerging from interpolator 312. For this reason, the interpolator 312 is advanced on odd and even cycles as shown in FIG. 2(f), except for when the pipeline is stopped. 
     FIGS. 2(h) and 2(j) respectively illustrate a command --  set signal output to interpolator 312 during the non-rendering and rendering states of control process 1. As shown in FIG. 2(h), when control process 1 is not processing a rendering instruction, the line driver of control process 1 accesses the data bus to interpolator 312 during even clock phases. However, if a rendering instruction is being processed, FIG. 2(j) illustrates that values may still be sent to interpolator 312 by control process 2 during odd clock phases even if a pipeline stop has been issued by output formatter 318 as a result of a cache miss and the like (FIG. 2(c)). In other words, if control process 1 is performing a render and the pipeline has been stopped, control process 2 will continue to process commands from command register 306 until it reaches a command which it is not authorized to handle. At this time, it will stop processing and wait for the current rendering process to end. 
     FIGS. 2(g) and 2(i) illustrate how a command pass-through may be implemented in accordance with the invention. Namely, FIG. 2(g) shows that a command in command register 306 which is not to be processed by the current data pipeline may be passed through to downstream hardware during an even clock state under control of control process 1 so long as a render is not being conducted. However, as illustrated in FIG. 2(i), if a rendering instruction is being processed, no commands are sent downstream since this capability is not available to control process 2. 
     The invention herein described thus allows pipelined instructions to be processed out of order without losing track of the ordering and without requiring use of complex resource allocation algorithms. By using the phase of the system clock to allocate access to data buses and to specify which of two or more control processes are to control the other critical resources, resource allocation problems may be reduced to a triviality. Thus, a pipelined processing system is disclosed which allows dynamic scheduling of a pipelined processor by using a clock phase to determine which of two or more parallel control processes have control over the critical resources of the data pipeline. For example, while one primitive is being rendered, the invention allows subsequent pipeline commands to be sorted and preprocessed without disrupting the rendering process. This provides for faster pipeline execution by removing pipeline &#34;stalls&#34; between primitives and hence substantially improves execution time. 
     Although an exemplary embodiment of the invention has been described in detail above, those skilled in the art will readily appreciate that many additional modifications are possible in the exemplary embodiment without materially departing from the novel teachings and advantages of the invention. In particular, the techniques in accordance with the invention may be applied to substantially different types of commands in other processing environments besides computer graphics systems. For example, the technique of the invention may be used for determining Fourier transform coefficients since such a calculation lends itself to special purpose processing. The technique of the invention may also be used in RISC processors which are pipelined or superpipelined. Moreover, the technique of the invention may be applied to a matrix multiplier. Accordingly all such modifications are intended to be included within the scope of this invention as defined in the following claims. ##SPC1##