A data processing system and method

Abstract: An out-of-order issue mechanism for a data processing system allows two out-of-order instructions to be issued to independent "pipes" from a window of four instructions currently queued for execution. If the two pipes execute floating pipe operations, dependencies between a computationally intensive floating point unit instruction (referred to as an fpu rr instruction) and the two previous computational intensive instructions having a target and a floating point register (the "fpr target") are tracked to provide a mechanism that quickly determines when dependent data is available from one of the floating point unit pipes. The data is then used to preempt the issue of a dependent instruction until data is available. Additionally, this out-of-order issue mechanism recognizes when consecutive instructions are dependent upon a same operand. In this situation, the mechanism prioritizes the first of the two instructions to be issued to the pipe satisfying the dependency, while the second instruction is preempted in favor of issuing an independent instruction or an instruction whose dependent data has already been made available to the other pipe when such an instruction is waiting in a queue.

Description: The present invention relates in general to a data processing system, and more particularly, to an out-of-order issue mechanism in a data processor. As computers have been developed to perform a greater number of instructions at greater speeds, many types of architectures have been developed to optimize this process. For example, a reduced instruction set computer (RISC) device utilizes fewer instructions and greater parallelism in executing those instructions to ensure that computational results will be available more quickly than the results provided by more traditional data processing systems. In addition to providing increasingly parallel execution of instructions, some data processing systems implement out-of-order instruction execution to increase processor performance. Out-of-order instruction execution increases processor performance by dynamically allowing instructions dispatched with no data dependencies to execute before previous instructions in an instruction stream that have unresolved data dependencies. In some data processing systems, instructions are renamed and instruction sequencing tables, also referred to as re-order buffers, facilitate out-of-order execution by reordering instruction execution at instruction completion time. Re-order buffer devices are also used to allow speculative instruction execution. Therefore, data processing systems which support speculative instruction execution can be adapted for out-of-order execution with the addition of relatively minimal hardware. A portion of this added hardware includes issue logic which is used to determine a time and order that instructions should be issued. Such issue logic can be extremely complex since the dependencies of instructions and a state of a pipeline in which the instructions are being executed must be examined to determine a time at which the instruction should issue. If the issue logic is not properly designed, such issue logic can become a critical path for the data processing system and limit the frequency of instruction execution such that performance gains which could be achieved by out-of-order issue are destroyed. Therefore, an out-of-order issue mechanism is desirable that efficiently issues independent instructions in a timely manner and that does not limit a frequency with which the processor executes instructions. European Patent Application No. EP 0 778 519 A2 describes a microprocessor with a dispatch unit which dispatches a maximum number of instructions each cycle, without splitting into separate blocks after a branch instruction. A mispredicted branch is handled by setting a valid bit to invalid for instructions following the branch instruction in an outstanding instruction FIFO. Accordingly, the invention provides a data processing system and method according to claims 1 and 34. According to a first aspect, the present invention provides a data processing system, comprising: input means for receiving a plurality of instructions; a first execution unit; storage means for storing a validity value wherein the storage means stores a plurality of validity values, each of the validity values correspondent to a respective of the instructions, in which a first one of the plurality of validity values selectively indicates a first one of a plurality of instructions may be issued to a first execution unit, characterised in that: a second execution unit, in which a second one of the plurality of validity values selectively indicating a second one of the plurality of instructions may be issued to the second execution unit. According to a second aspect, the present invention provides a method for issuing instructions in a data processing system having a first execution unit, comprising the steps of: receiving a plurality of instructions, wherein the step of storing the validity value comprises storing a plurality of validity values, in which each of the plurality of validity values corresponds to a respective one of the plurality of instructions; selectively enabling a first one of the plurality of validity values to indicate the first one of the plurality of instructions may be issued to the first execution unit; characterised in that: utilizing a second one of the plurality of validity values to selectively indicate a second one of the plurality of institutions may be issued to a second execution unit. Another preferred embodiment provides a data processing system having a first execution unit and a second execution unit. The data processing system includes an input circuit for receiving a first plurality of instructions. The data processing system also includes a detection circuit for detecting dependencies between a first one of the first plurality of instructions and a second instruction currently executing within the first execution unit and asserting a first dependency indicator in response to a first dependency. The detection circuit is connected to the input circuit for receiving the first plurality of instructions. The data processing system also includes an issue circuit connected to the first execution unit, the second execution unit and the detection circuit. The issue circuit selectively issues the first one of the plurality of instructions to one of the first execution unit and the second execution unit in response to the first dependency indicator. Another preferred embodiment of the present invention provides a method for operating a data processing system having a first execution unit and a second execution unit. The method includes the steps of receiving a first plurality of instructions and detecting dependencies between a first one of the first plurality of instructions and a second instruction currently executing within the first execution unit. The method also includes the steps of asserting a first dependency indicator in response to a first detected dependency, coupling an issue circuit to the first execution unit, the second execution unit and the detection circuit, and selectively issuing the first one of the first plurality of instructions to one of the first execution unit and the second execution unit in response to the first dependency indicator. Another preferred embodiment of the invention provides a data processing system including a first execution unit for selectively executing a first plurality of instructions and an instruction issue logic circuit for generating a plurality of issue bits. A first preselected number of issue bits corresponds to one of the first plurality of instructions and the first preselected number of issue bits selectively enables a first instruction to be executed. Additionally, another preferred embodiment of the present invention provides a method for operating a data processing system. The method includes the steps of selectively executing a first plurality of instructions in a first execution unit and generating a plurality of issue bits using an instruction issue logic circuit. A first preselected number of issue bits correspond to one of the first plurality of instructions. The method also includes the step of selectively enabling a first instruction to be executed in response to the first preselected number of issue bits. A preferred embodiment of the invention will now be described in detail by way of example only with reference to the following drawings: FIGURE 1 illustrates, in block diagram form, a data processing system; FIGURE 2 illustrates, in block diagram form, a central processing unit from the data processing system of Figure 1; FIGURE 3 illustrates, in block diagram form, a floating point unit of the central processing unit of FIGURE 2; FIGURES 4A and 4B illustrate, in block diagram form, a floating point unit rename and decode logic circuit of FIGURE 3; FIGURE 5 illustrates, in timing chart form, instructions executed in two pipes of the data processing system of Figures 1-4; FIGURE 6 illustrates, in timing chart form, two pipes of instructions executed by the data processing system of Figures 1-4; FIGURES 7-1 to 7-41 illustrate, in flow diagram form, operations executed by a data processing system in accordance with one embodiment of the present invention; FIGURE 8 illustrates, in flow diagram form, an out-of-order issue queue maintenance operation for a first pipe in accordance with one embodiment of the present invention; FIGURE 9 illustrates, in flow diagram form, an out-of-order issue operation of a second pipe in one embodiment of the data processing system of the present invention; FIGURE 10-1 illustrates, in flow diagram form, an issue operation executed in accordance with one embodiment of the present invention; and FIGURES 10-2 to 10-11 illustrate, in logic diagram form, portions of the operations executed in accordance with the flow diagram of FIGURE 10-1. The preferred embodiment provides an out-of-order issue mechanism for a data processing system which allows two out-of-order instructions to be issued to two independent "pipes" from a window of four instructions currently queued for execution. The two pipes execute floating point operations. In this embodiment, dependencies between a computational intensive floating point unit instruction (referred to as a fpu rr instruction) and the two previous computational intensive instructions having a target in a floating point register (the "fpr target") are tracked to provide a mechanism that quickly determines when dependent data is available from one of the floating point unit pipes. This data is then used to preempt the issue of a dependent instruction until data is available. Furthermore, the preferred embodiment recognizes when consecutive instructions are dependent upon the same operand. In this situation, the preferred embodiment prioritizes a first of the two instructions to be issued to the pipe satisfying the dependency, while the second instruction is preempted in favor of issuing an independent instruction or an instruction whose dependent data has already been made available to the other pipe when such an instruction is waiting in a queue. Each of these functions is provided without impacting a cycle time of the data processing system and without increasing the number of cycles required to issue floating point instructions to the floating point unit pipelines. In one embodiment of the present invention, several components are used to implement an out-of-order issue mechanism. In a first portion, a "history circuit" maintains the target information and the validity of the previous two fpu rr instructions having an fpr target. In a second portion of the out-of-order issue mechanism, an issue state determination circuit combines information obtained from the history circuit with the dispatched instructions to determine an issue state for each instruction to one of two pipes implemented therein. The issue state determination circuit generates two bits of data for each of four dispatched instructions. One of these bits indicates when the instruction is available for issue to a first pipe and the second bit indicates when the instruction is available for issue to a second pipe. Through the use of these two bits, the issue state determination circuit "tags" each instruction in an instruction queue. In a third portion of the out-of-order issue mechanism, a state of the two issue state bits of the instruction are maintained in the instruction queue until the instruction is issued. A fourth portion of the out-of-order issue mechanism implements a logic circuit which observes the issue state bits of a predetermined number of instructions at the bottom of the instruction queue to determine which of the instructions should be issued. Description of Connectivity Refer now to the drawings wherein depicted elements are not necessarily shown to scale and wherein like or similar elements are designated by the same reference numeral through the several views. Referring first to FIGURE 1, an example is shown of a data processing system having a central processing unit (CPU) 110, such as a PowerPC microprocessor ("PowerPC" is a trademark of IBM Corporation) according to "The PowerPC Architecture: A Specification for a New Family of RISC Processors", 2d edition, 1994, Cathy May, et al. Ed.. A more specific implementation of a PowerPC microprocessor is described in the "PowerPC 604 RISC Microprocessor Users Manual", 1994, IBM Corporation. The history buffer (not shown) is included in CPU 110. The CPU 110 is coupled to various other components by system bus 112. Read only memory ("ROM") 116 is coupled to the system bus 112 and includes a basic input/output system ("BIOS") that controls certain basic functions of the data processing system. Random access memory ("RAM") 114, I/O adapter 118, and communications adapter 134 are also coupled to the system bus 112. I/O adapter 118 may be a small computer system interface ("SCSI") adapter that communicates with a disk storage device 120 or other form of storage device (eg tape) 140. Communications adapter 134 interconnects bus 112 with an outside network enabling the data processing system to communication with other such systems. Input/Output devices are also connected to system bus 112 via user interface adapter 122 and display adapter 136. Keyboard 124, track ball 132, mouse 126 and speaker 128 are all interconnected to bus 112 via user interface adapter 122. Display monitor 138 is connected to system bus 112 by display adapter 136. In this manner, a user is capable of inputting to the system through the keyboard 124, trackball 132 or mouse 126 and receiving output from the system via speaker 128 and display 138. Additionally, an operating system such as AIX ("AIX" is a trademark of the IBM Corporation) is used to coordinate the functions of the various components shown in FIGURE 1. According to the particular computer system implementation, sets of instructions for executing the method or methods of the invention are resident in the random access memory 114 of one or more computer systems configured generally as described above. Until required by the computer system, the set of instructions may be stored as a computer program product in another computer memory, for example, in disk drive 120 (which may include a removable memory such as an optical disk or floppy disk for eventual use in the disk drive 120). Further, the computer program product can also be stored at another computer and transmitted when desired to the user's work station by a network or by an external network such as the Internet. FIGURE 2 illustrates a portion of CPU 110 in greater detail. The portion of CPU 110 comprises an instruction cache (I-cache) 202, an instruction unit/branch unit 204, a fixed point execution unit (fxu) 206, a load/store unit 208, a floating point unit (fpu) 210, a data cache (D-cache) 212, and a bus interface unit (BIU) 214. I-cache 202 is coupled to instruction unit/branch unit 204 to communicate control information and a plurality of instructions. Instruction unit/branch unit 204 is coupled to each of FXU 206, load/store unit 208, and FPU 210 to provide a plurality of dispatched instructions. I-cache 202 is coupled to bus interface unit 214 to communicate Data and Control information. FXU 206 is coupled to load/store unit 208 to communicate a load data value, a store data value, and a forwarding data value. Load/store unit 208 is coupled to FPU 210 to communicate a store data value and load data value. Load/store unit 208 is also coupled to D-cache 212 to communicate a request for a load/store signal, a plurality of data values, and an address value. D-cache 212 is coupled to bus interface unit 214 to communicate a data in signal, a data out signal, and a control signal. FIGURE 3 illustrates a portion of floating point unit 210 in greater detail. A portion of FPU 210 comprises a FPU rename and decode logic circuit 302, a FPU instruction queue 304, an issue logic circuit 306, a rename buffer/FPR (floating point register) 308, a FPU pipe 0 310, and a FPU pipe 1 312. A plurality of dispatched instructions, Inst0, Inst1, Inst2, and Inst3 are coupled to FPU rename and decode logic 302. Additionally, the control signal provides a Valid0 signal, a Valid1 signal, a Valid2 signal, and a Valid3 signal, to FPU rename and decode logic 302. FPU rename and decode logic 302 is coupled to FPU instruction queue 304 to provide a plurality of decoded instructions. FPU instruction queue 304 is coupled to issue logic 306 to provide a plurality of control signals. Issue logic 306 is coupled to rename buffer/FPR 308 to provide a first plurality of operand pointer signals and a second plurality of operand pointer signals. Issue logic 306 is coupled to FPU pipe 0 310 to provide a plurality of Pipe 0 control signals. Issue logic circuit 306 is coupled to FPU pipe 1 312 to provide a plurality of Pipe 1 control signals. Rename buffer/FPR 308 is coupled to FPU pipe 0 310 to communicate A operand (aop) signals, B operand (bop) signals, C (cop) operand signals, and result 0 signals. Similarly, rename buffer/FPR 308 is coupled to FPU pipe 1 312 to communicate A operand signals, B operand signals, C operand signals, and result 1 signals. A portion of FPU rename and decode logic 302 is illustrated in greater detail in FIGURE 4. FPU rename and decode logic 302 comprises rename logic 402, instruction interlock detect logic 404, instruction target detect logic 406, instruction categorization logic 408, M2/M1 control logic 410, M2 update logic 412, M2 validity logic 414, M1 update logic 416, M1 validity logic circuit 418, M2 history register 420, M2 register 422, M2 register 424, M1 history register 426, M1 register 428, M1 register 430, functional unit dependency clearing check logic 432, instruction issue interlock detect circuit 434, and instruction issue state logic circuit 436. The Inst0, Inst1, Inst2, and Inst3 signals are coupled to rename logic 402, instruction interlock detect logic 404, instruction target detect logic 406, instruction categorization logic 408, M2 update logic 412, and M1 update logic 416. The Valid0, Valid1, Valid2, and Valid3 signals are coupled to M2/M1 control logic 410. Rename logic 402 is coupled to M2 update logic 412 and M1 update logic 416 to provide a plurality of rename signals. Instruction interlock detect logic circuit 404 is coupled to M2 validity logic 414 and instruction issue interlock detect circuit 434 to provide a plurality of interlock A signals. Similarly, instruction interlock detect logic 404 is coupled to M1 validity logic 418 and instruction issue interlock detect circuit 434 to provide a plurality of interlock B signals. It should be noted that three interlock signals are provided for each issued instruction. Each instruction potentially has a target and up to three sources, denoted as aop, bop, cop. Either aop, bop, cop or a combination of some or none may interlock with a previous instruction. Instruction target detect logic 406 is coupled to instruction interlock detect logic 404 to provide a target detect signal. Similarly, instruction target detect logic 406 is coupled to M2/M1 control logic 410 and instruction issue state logic 436 to provide a target detect signal. Instruction categorization logic 408 is coupled to M2/M1 control logic 410 to provide a categorization signal. M2/M1 control logic circuit 410 is coupled to M2 update logic 412, M2 validity logic 414, M1 update logic 416, and M1 validity logic 418. M2 update logic 412 is coupled to M2 history register 420. M2 history register 420 is coupled to functional unit dependency clearing check logic 432, M2 update logic 412, and instruction interlock detect circuit 404. M2 validity logic 414 is coupled to M2 register 422 and to M2 register 424. M2 register 422 and M2 register 424 are each coupled to instruction issue interlock detect circuit 434. M1 update logic 416 is coupled to M1 history register 426. M1 history register 426 is coupled to functional unit dependency clearing check logic 432 and instruction interlock detect circuit 404. M1 history register 426 is also coupled to M1 update logic 416. M1 validity logic 418 is coupled to M1 register 428 and to M1 register 430. M1 register 428 and M1 register 430 are coupled to instruction issue interlock detect 434. Instruction interlock detect circuit 434 is coupled to instruction issue state logic 436. Functional unit dependency clearing check logic 432 is coupled to instruction issue state logic 436. Additionally, a plurality of p0_e2_bfr signals, a plurality of p0_e3_bfr signals, a plurality of p1_e2_bfr signals, and a plurality of p1_e3_bfr signals are each provided to functional unit dependency clearing check logic 432. In one embodiment of the present invention, each of the plurality of po_e2 bfr signals, po_e3 bfr signals, p1_e2 bfr signals, and p1_e3 bfr signals is comprised of five signals. Description of Operation During operation of the data processing system of Figures 1-4, instructions are fetched from I-cache 202 and provided to instruction unit/branch unit 204 with the appropriate control signals for their execution. Operation of an instruction cache, such as I-cache 202, is well-known in the data processing art and, therefore, will not be described in greater detail herein. Within instruction unit/branch unit 204, the instructions provided by I-cache 202 are stored in registers. Specifically, there are four dispatch registers (not illustrated herein) in one embodiment of the present invention. Each of these four dispatched registers is accessed and four instructions are selectively dispatched in a single cycle therefrom. Furthermore, each of the four dispatch registers include an instruction part, an instruction pre-decode part, and an instruction valid part. It should be noted that any number of dispatch registers may be implemented in the present invention with a corresponding modification in a remaining portion of the logic in the data processing system. As previously mentioned, the dispatch registers included in instruction unit/branch unit 204 include a pre-decode mechanism. This mechanism provides partially decoded information describing an instruction type and target information to facilitate the speedy determination of instruction characteristics. Furthermore, an instruction valid portion of the dispatch registers indicates that an instruction stored within a dispatch register is valid and may be accessed to perform a correct computing function. The use of valid portions and pre-decode mechanisms within an instruction dispatch register is well-known in the data processing art and, therefore, will not be described in greater detail herein. Information about each of the instructions is transferred to an appropriate one of FXU 206, load/store unit 208, and FPU 210 via the dispatched instructions. The functions generally performed by each of devices 206, 208, and 210 are also well-known in the data processing art and, therefore, will not be described in greater detail. Refer now to FIGURE 3 for a more detailed description of operation of FPU 210. When each of the four instructions stored in the four dispatch registers of instruction unit/branch unit 204 is accessed, the instructions are provided to FPU rename and decode logic circuit 302 of FIGURE 3. Each of these dispatched instructions is referred to as one of Inst0, Inst1, Inst2, and Inst3. Additionally, validity portions of each of the instructions is provided via a respective one of the Valid0, Valid1, Valid2, and Valid3 signals provided via a control bus. FIGURE 4 provides a more detailed illustrateion of FPU rename and decode logic circuit 302. During operation, dispatch instruction pre-decode information is decoded to determine an instruction type in instruction categorization logic 408 of FPU rename and decode logic circuit 302. Instruction categorization logic 408 determines a type of instruction which is currently being executed. Instruction categorization logic 408 determines whether an instruction is a floating point unit arithmetic instruction, referred to as a fpu rr , a floating point load operation, or a floating point unit store operation. Furthermore, instruction categorization logic circuit 408 determines which sources are used by the instruction. In one embodiment of the invention, three sources may be used by an instruction. These three sources are referred to as "a", "b" and "c." In FIGURE 4, instruction target detect logic 406 determines whether an fpr register is used by an instruction currently being executed to store results. Information about the use of an fpr register to store results is also encoded in the pre-decode bits of the dispatched instruction in one embodiment of the present invention. Therefore, the pre-decoded bits of the instruction are decoded to determine if the instruction possesses a target fpr. For instance, "compare" instructions have no fpr target, but a multiply instruction does have an fpr target. While instruction target detect logic circuit 406 is making this determination, instruction interlock detect logic circuit 404 determines whether any of the four dispatched instructions are interlocked. The term interlock indicates that multiple instructions have data interdependencies. Furthermore, instruction interlock detect logic circuit 404 determines the existence of potential interlock situations between dispatched instructions and instructions saved in either M2 history register 420 or M1 history register 426. It should be noted that an interlock situations occurs when data accessed by one of the four instructions is generated by another one of the four instructions being concurrently executed. During operation, instruction interlock detect logic 404 provides the Interlock A and Interlock B signals to both M2 validity logic 414 and M1 validity logic 418. Each of M2 validity logic 414 and M1 validity logic 418 uses this information to invalidate information stored in M2 history register 420 and M1 history register 426, respectively. Instruction issue interlock detect circuit 434 identifies matches between dispatched instructions and instructions maintained in M2 history register 420 and M1 history register 426 to identify "breaks" in dependencies due to an interspersed instruction having the identical target location as the previous instruction. When such breaks are detected, the dependency of a dispatched instruction upon the history register is suppressed and the dependency on the dispatched instruction is asserted instead. To detect such breaks in instruction interlock detect logic 404, targets of a dispatched instruction are compared with the targets of previous instructions which are stored in a respective one of M2 history register 420 and M1 history register 426. If the dispatched instruction has an fpr target (i.e., a target of a fpu rr instruction), a target stored in one of M1 history register 426 and M2 history register 420 is invalid if it matches the fpr target value. Furthermore, rename logic 402 receives each of the Inst0 through Inst3 instructions and determines an fpr target corresponding to that instruction. Each of the fpr targets of the instructions are allocated to a corresponding rename buffer/FPR location, where the results of the instructions' executions are temporarily stored until the instructions complete. Rename logic 402 subsequently provides the allocated rename buffer locations to M2 update logic 412 and M1 update logic 416, which respectively selectively store the buffer location within M2 history register 420 and M1 history register 426. It should be noted that rename logic 402 and the functions served thereby are well-known to those with skill in the data processing art and, therefore, will not be described in greater detail. M2/M1 control logic circuit 410 also provides control information for M2 update logic 412 and M1 update logic 416. M2/M1 control logic circuit 410 uses the decoded instruction classification information provided by instruction categorization logic 408 and fpr target information provided by instruction target detect logic 406 to determine a number of fpu rr instructions having a target dispatched in a current cycle. M2/M1 control logic circuit 410 uses this information to control the storage of a dispatch state and the moving or holding of a history state value in one of M2 history register 420 and M1 history register 426. If no fpu rr instruction having an fpr target is dispatched in the current cycle, then a second, or M2, history state is stored in M2 history register 420 and a first, or M1, history state is stored in M1 history register 426. Conversely, if one fpu rr instruction has an fpr target and is dispatched in a current timing cycle, then a state of the dispatched fpu rr instruction is saved in M1 history register 426. Furthermore, the contents of M1 history register 426 are transferred to M2 history register 420 via M2 update logic 412. Furthermore, if two or more fpu rr instructions both have an fpr target and are dispatched in a current timing cycle, then the state of the last two fpu rr instructions dispatched and having a fpr target are saved in M2 history register 420 and M1 history register 426, respectively. Stated another way, a state of the next to last fpu rr instruction dispatched and having an fpr target is saved in M2 history register 420. Similarly, a last fpu rr instruction dispatched and having a fpu target is saved in M1 history register 426. Control for making each of these transfers to and from M2 history register 420 and M1 history register 426 is provided by M2/M1 control logic 410, in conjunction with M2 update logic 412 and M1 update logic 416, respectively. During operation, a state maintained in each of M2 history register 420 and M1 history register 426 includes an fpr target of the corresponding instruction, a rename buffer location associated with the target for that instruction, a valid bit for dependency checking of a first operand (a V) and a valid bit for dependency checking of a second or third operand (bc V). An fpr target state is maintained in M2 history register 420 and M1 history register 426 and is used by instruction interlock detect logic 404 to determine potential interlocks between an instruction residing in a history state register and the dispatched instructions. Only an indication of the target, the rename buffer, and their validity to interlock determinations for aop (a operand) and bop (b operand) or cop (c operand) are stored in the history state register. The instruction itself is queued on instruction queue 304. The state registers are maintained in rename and decode logic 302. The pointers (i.e., the fpr target pointer) for M2 history register 420 and M1 history register 426 are provided to the instruction interlock detect logic 404 which compares these fpr target pointers with the fpr source operand pointers of each dispatched instruction for potential interlocks. This comparison is provided to the instruction issue interlock detect logic 434, where it is qualified with the validity of the appropriate operand and the interlock "breaks" mentioned earlier to determine if interlocked. Interlock detect logic circuit 404 performs this function through the use of pointers. The pointers (i.e. the fpr target pointer) for M2 history register 420 and M1 history register 426 are provided to instruction interlock detect circuit 404 which compares these fpr target pointers with fpr operand pointers for each instruction to determine when potential interlocks occur. This comparison result is provided to instruction interlock detect logic 404, where it is qualified with the validity of the appropriate operand and the interlock "breaks" to determine if an interlock condition has occurred. The results of operations of instruction interlock detect logic 404, together with the "a V" and "bc V" validity bits are provided to instruction issue interlock detect logic circuit 434 to identify when an interlock situation persists. If instruction interlock detect logic circuit 404 detects a potential interlock situation between a dispatched instruction and an instruction in one of M2 history register 420 and M1 history register 426, the result is logically combined with a corresponding valid bit to determine when the interlock has and has not been cleared by execution of one of FPU pipe 0 310 or FPU pipe 1 312. It should be noted that in one embodiment of the present invention, this logical combination is a logical AND function. Furthermore, it should be well-known to those skilled in the art that additional logical combinations may be implemented where the circuitry so requires. During the previously described operations, targets to rename buffer locations associated with fpr targets in the M2 history register 420 and M1 history register 426 are compared with target rename buffer locations piped with an instruction down one of FPU pipe 0 310 and FPU pipe 1 312. This comparison operation is performed to determine whether a detected dependency is being cleared in a current timing cycle. The comparison operation is performed by functional unit dependency clearing check logic 432. It should be noted that the target rename buffer locations are provided by the plurality of p0_e2_bfr signals, the plurality of p0_e3_bfr signals, the plurality of p1_e2_bfr signals, and the plurality of p1_e3_bfr signals. Each of the p0_e2_bfr signal, p0_e3_bfr signal, p1_e2_bfr signal, and p1_e3_bfr signal is provided to the functional unit dependency clearing check logic 432 by control units (not illustrated) within FPU pipe 0 310 and FPU pipe 1 312. It should be noted that bop and cop dependencies are cleared when a data generating instruction is in either the e2 stage of FPU pipe 0 310 or FPU pipe 1 312. FIGURE 5 illustrates a series of stages of each of FPU pipe 0 310 and FPU pipe 1 312. In FIGURE 5, instruction i1 is assumed to have a bop or cop dependency on instruction i0. In one embodiment to the present invention, assume that three cycle forwarding exists from a write back (WB) stage to a first execution (el) stage for bop and cop dependencies. Thus, as illustrated in FIGURE 5, instruction i1 executes in an e1 stage of FPU pipe 0 310 as instruction 10 executes in a WB stage of FPU pipe 0 310. Before proceeding further with this example, a description of the acronyms utilized in FIGURE 5 will be provided below. The acronyms and their definition are as follows: DR = instruction dispatch/register rename stage e0 = operand fetch stage e1 = execute one stage e2 = execute two stage e3 = execute three stage WB = write result to rename buffer (hidden) or a write back stage FI = finish (hidden) stage CP = complete (hidden) stage WV = write back vector to FPR (hidden) stage PR = prioritize for FPR write (hidden) stage CB = copy from rename buffer to FPR (hidden). With these acronyms so defined, FIGURE 5 illustrates that when instruction i1 is dispatched and an instruction 10 is in the e2 stage of FPU pipe 0 312, then a dependency of instruction i1 upon instruction 10 may be satisfied by forwarding logic (illustrated in FIGURE 3) if instruction i1 is issued to the one of FPU pipe 0 310 and FPU pipe 1 312 which is currently clearing the dependency. A dependency between an i1 or an i2 instruction occurs in some situations. For example, assume that a fadd instruction is followed by a fmul instruction, where the fadd instruction is a "floating point add" and, therefore, a fpu rr instruction. Additionally, assume the aop and bop values are a source of the fadd instruction and the fmul instruction sources the aop and cop values in a next instruction cycle. This relationship may be expressed in the following manner: fadd target ← aop + bop; and fmul target ← aop x cop. As may be observed, the aop of the fmul instruction is dependent upon the execution of the fadd instruction when the fpr designated for the aop of the multiply instruction is the same as the target location for the fadd instruction. For example, assume the following instructions are to be executed: fadd (5) ← (1) + (2); fmul (6) ← (5) x (8); where (z) means contents of location z. As may be observed from the example provided above, the fadd instruction has target of (5). This location is subsequently referred to as the aop for the fmul instruction. Therefore, an aop dependency exists between the fadd and fmul instruction. A description of one embodiment of the present invention which clears such dependencies will subsequently be provided below. In this type of operation, the bop and cop dependencies are cleared when an instruction from which a subsequent instruction depends, is executing in the e2 stage of one of FPU pipe 0 310 and FPU pipe 1 312. For example, consider the above instruction sequence in which the cop of the fmul is dependent on the execution of the fadd instruction in a manner illustrated below: fadd (5) ← (1) + (2); fmul (6) ← (8) x (5). In this example, an issue state bit to a pipe clearing the dependency is asserted because a value in the M1 history register rename buffer pointer 308 matches the target rename buffer pointer in a pipe's (310 or 312) e2 stage. Stated another way, if instruction 10 is executing in the e2 stage of FPU pipe 1 312 when instruction i1 is dispatched, functional unit dependency clearing check logic circuit 432 will compare a rename buffer location pointer allocated to a target of instruction 10 and residing in M1 history state register 420 with the rename buffer pointer allocated to the target of the instructions executing in the e2 stage of FPU pipe 1 312 (in this case instruction i0). The target of the instruction executing in the e2 stage of FPU pipe 1 312 is provided as a p1_e2_bfr signal to functional unit dependency clearing check logic 432. When the pointers match, as in this case, an indication is provided to instruction issue state logic 436 to assert the issue bit to the matching pipe (in this case, FPU pipe 1 312). Functional unit dependency clearing check logic 432 subsequently provides a signal which selectively enables instruction issue state logic 436 to assert an issue bit to FPU pipe 1 312 for instruction i1 in response to this comparison operation. Furthermore, since an instruction only executes in one of FPU pipe 0 310 and FPU pipe 1 312 and a rename buffer location associated with a target is unique because of the configuration of rename logic 402, a bop rename buffer (not illustrated in detail herein) matches the target rename buffer in only one of FPU pipe 0 310 and FPU pipe 1 312. Therefore, only the issue bit provided to a matching one of FPU pipe 0 310 and FPU pipe 1 312 e2 stage will be asserted. The issue bit is also subsequently provided to FPU instruction queue 304 (of FIGURE 3) to indicate that a bop or cop dependent instruction is only available for issue in the following cycle to the FPU pipe (FPU pipe 0 310 or FPU pipe 1 312) identified by the issue bit(s). Aop dependencies are handled in a similar manner to bop and cop dependencies. However, when cop dependencies are detected, the e3 stage of the pipeline is compared. Additionally, when an interlock clearing operation occurs, the issue bits to both FPU pipe 0 310 and FPU pipe 1 312 are asserted. While the state of the issue bits is being determined, functional unit dependency clearing check logic 432 invalidates a "bc V" bit of a corresponding history register when the "bc V" bit recurs in either the M2 history register 420 or M1 history register 426 in a following timing cycle when the dependency clearing logic matches the history buffer pointer with the buffer pointers in the e2 stage of either FPU pipe 0 310 or FPU pipe 1 312. When the "bc V" bit has been cleared from one of M2 register 424 or M1 register 430, a dependency is not detected by instruction interlock detect circuit 434 or instruction issue state logic 436. Therefore, instruction issue state logic 436 asserts issue bits to both FPU pipe 0 310 and FPU pipe 1 312. If a dependency is detected between a bop or cop of an instruction and either M2 history register 420 and M1 history register 426, and a corresponding "bc V" bit is asserted, and the M2 or M1 rename buffer pointer does not match the FPU pipe 0 or FPU pipe 1 e2 stage rename buffer pointer, then neither issue bit is asserted. FPR targets of previous instructions are compared to fpr instruction pointers of source operands of subsequent instructions to determine whether the source of a subsequent instruction is being calculated by the previous instruction. This dependency is detected between a bop or cop pointer of an instruction and target pointers residing in M2 history register 420 and M1 history register 426. If the "bc V" bit is asserted, the comparison of the current and previous instruction indicates that the dependency exists preventing the setting of issue bits unless dependency clearing logic determines otherwise, as discussed above. Subsequently, the "bc V" bit may be reset by determining if a pipe has calculated the dependent value by the time the dependent instruction is issued. This operation is accomplished by comparing a pointer into a first location of rename buffer 308 allocated by rename logic 402 to the target of the instruction whose history is maintained in M2 history register 420 or M1 history register 426 with a pointer into a second location of rename buffer 308 allocated by rename logic 402 to the target of the instruction being executed in an appropriate stage of either pipe. In one embodiment of the present invention, an appropriate stage to reset the "bc V" bit is the e2 stage of either pipe. More specifically, the pointer into the rename buffer location allocated to the target of the instructions whose history is in M2 history register 420 is compared to p0_e2_bfr signals and to p1_e2_bfr signals. A corresponding "bc V" value is reset when the instruction history in M2 history register 420 is to be retained in M2 history register 420 in a next timing cycle. A similar operation occurs for comparisons in M1 history register 426. Additionally, if the contents of M1 history register 426 are transferred to M2 history register 420 in a cycle, a pointer of M1 history register 426 into the rename buffer location allocated to its target is compared to the plurality of p0_e2_bfr and p1_e2_bfr signals to determine if the "bc V" stored in M2 register 424 is to be reset during the next timing cycle. Additionally, when the pointer into the rename buffer location allocated to the target of the instruction whose history is in M2 history register 420 or M1 history register 426 matches the pointer into the location rename buffer allocated to the target of the instructions executing in the e2 stage of one of the pipes, the issue bit for the matching pipe is asserted for a currently dispatched instruction possessing a bop or cop dependency on the instruction whose history is stored in M2 history register 420 or M1 history register 426, while the issue bit for the non-matching pipe is left unasserted. A methodology for determining when dependencies on an aop (a operand) should be issued is similar to the methodology described above for determining when instructions with bop or cop dependencies should be issued with two exceptions. FIGURE 6 illustrates the stages of execution of two instructions in FPU pipe 0 310 when the instructions have an aop dependency. As illustrated in FIGURE 6, aop dependencies are cleared in the e3 stage of a pipe, because forwarding from a WB (write back) stage to the dependent aop is only allowed into the e0 stage of either pipeline. This requirement is due to timing considerations in one embodiment of the invention. In this embodiment of the present invention, a multiply instruction typically occurs between a value aop and a cop value. Furthermore, as is performed in state-of-the-art multiply implementations, one of aop or cop values is Booth recoded to reduce the number of partial products that are produced. In one embodiment of the present invention, the aop is chosen for Booth recoding. During execution of a multiplication operation, the timing path is too lengthy to forward the result from the WB stage of a pipe into the e1 stage of the pipe and then execute Booth recoding, partial product generation, and partial product reduction for the multiplication operation. However, the result in the WB stage of the pipe may be forwarded to the cop value while the aop value is being Booth recoded. Therefore, an operand is forwarded to only an e0 stage of a pipe during an access of an aop value. Thus, FIGURE 6 illustrates that when instruction i1 is dispatched and instruction i0 is in the e3 stage of FPU pipe 0 310, the data is available for forwarding to the e0 stage of instruction i1. Therefore, the dependency is cleared for an aop when the instruction upon which the "a" operand is dependent is executing in the e3 stage of either pipe. Secondly, any operand (a, b, or c) may be forwarded into an e0 cycle for a corresponding FPU pipe. Therefore, in the example illustrated in FIGURE 6, when functional unit dependency clearing check logic circuit 432 determines that an instruction upon which a subsequent instruction is dependent is executing in an e3 stage of one of FPU pipe 0 310 and FPU pipe 1 312, functional unit dependency clearing check logic 432 enables instruction issue state logic 436 to assert issue bits to both FPU pipe 310 and FPU pipe 1 312 to indicate that a dependent instruction can be issued to either of the pipes in the following timing cycle. Concurrently, the "a V" bit of one of M2 register 422 and M1 register 428 is negated if the instruction remains on either of M2 history register 420 or M1 history register 426 in a subsequent timing cycle and the instruction whose target history is in M2 history register 420 or M1 history register 426 has executed in the e3 stage of either pipe. Therefore, the dependency will not be detected for subsequently dispatched instructions. Additionally, the issue bits will be asserted to both FPU pipe 0 310 and FPU pipe 1 312 for those instructions. ' The aforementioned description provides a basic explanation of operation of the out-of-order mechanism. However, the preferred embodiment also provides solutions for more difficult cases in which a determination of issue bits' logic states is more difficult. The determination of issue bits is further complicated when instructions have multiple operands that are dependent upon different instructions within a "checking window." For example, assume that instruction 12 has a bop (b operand) that is dependent upon instruction i1 and a cop (c operand) that is dependent upon instruction i0. Furthermore, assume that instruction i0 is stored within M2 history register 420 and instruction i1 is stored within M1 history register 426. Additionally, assume that instruction i0 is in an e2 stage of FPU pipe 0 310 and instruction i1 is in an e2 stage of FPU pipe 1 312. As described above in this situation, the issue bit to FPU pipe 0 310 would be asserted to reflect the "b" operand (bop) dependency and the issue bit to FPU pipe 1 312 would be asserted to reflect the cop dependency. However, in this example, the instruction cannot issue in a next timing cycle since instruction i2 would have to issue to FPU pipe 0 310 to forward into the "c" operand (cop) in the e1 stage of FPU pipe 0 310 and instruction i2 would issue FPU pipe 1 312 to forward into its b operand (bl) in the e1 stage of FPU pipe 1 312. Clearly, both operations do not occur concurrently. To handle such cases, three additional status bits are defined, generated upon dispatch from instruction unit/branch unit 204, and maintained in queues. As is illustrated in FIGURE 4, these queues follow the issue bit generation logic (i.e., instruction issue state logic 436). These three additional status bits are respectively referred to as a_available, b_available, and c_available bits. Each of the a_available, b_available, and c_available bits allow the issue bits for the above cases to remain unasserted, but provide status information for each instruction to indicate when multiple dependencies have been cleared. Therefore, in the above case, the a_available bit would be asserted since the "a" operand (aop) has no dependency in instructions i0, i1, or i2. Additionally, since the "b" operand (bop) is satisfied by instruction i1 in FPU pipe 0 310 and the "c" operand (cop) is satisfied by the execution of instruction i2 and FPU pipe 1 312, the b_available and c_available bits are set. Subsequently, in a following cycle, the b_available and c_available bits appear in the queue; however, the issue bits remain unasserted in the queue. In this following timing cycle, instructions i0 and i1 are in the e3 stages of FPU pipe 0 310 and FPU pipe 1 312, respectively. Furthermore, instruction i2 is not issued. As will be discussed in greater detail below, when all of the operands (a, b, and c) are available, the issue bits to both FPU pipe 0 310 and FPU pipe 1 312 are asserted and stored in FPU instruction queue 304. Thus, in a second timing cycle, both issue bits are asserted and instruction i2 can issue into an e0 stage of an appropriate one of FPU pipe 0 310 and FPU pipe 1 312. In this cycle, both instruction i0 and instruction i1 are in a WB (write back) state of a corresponding pipe and available to be forwarded as the bop and cop in an e0 stage of either FPU pipe 0 312 or FPU pipe 1 312. As this instruction can issue equally well to either pipe, determination of the pipe to which it issues is determined by the other instructions within the four instruction window stored at the bottom of the queue. For example, if a second instruction selected for issue can issue only to FPU pipe 0 310, then the previously described instruction that can issue to either pipe, issues to FPU pipe 1 312 and vice versa. It should be noted that appropriate issue bits and a_available, b_available, and c_available bits are asserted when certain conditions are met. For example, the "available" bits are set when an operand is not required by the instruction. For example, for an "add" instruction in which an "a" operand is added to a "b" operand, the c_available bit would be asserted as the c operand is not required by the instruction. The c_available bit is also set during an instruction decode operation executed by FPU rename and decode logic circuit 302. As well, an available bit will be set when an operand is independent of other fpu rr instructions updating an FPR target within a window of three such instructions. For example, assume instructions i1 through i3 are independent of one another. Instruction i4 is dependent on instruction i1, but is not within the three instruction window implemented in one embodiment of the present invention. The following instructions illustrate this relationship: i1 fadd (0) ← (1) + (2); i2 fadd (3) ← (4) + (5); i3 fadd (6) ← (7) + (8); i4 fadd (9) ← (0) + (10). One embodiment of the present invention will indicate the aop, bop and cop values of instruction i4 are available and assert the issue bits to both FPU pipe 0 310 and FPU pipe 1 312. Other alternative implementations may also be implemented. For example, history buffer information may be maintained for more than the last two FPU rr instructions. Additionally, the dependencies between M2, M1, and each of instructions i1, i2, i3, i4 could be determined for any number of instruction windows. Furthermore, another embodiment of the present invention may implement different instruction window lengths for a number of instructions. For example, assume six instruction windows for 14, five instruction windows for i3, four instruction windows for i2, and three instruction window for i1, where i1, i2, i3, and i4 are the four dispatched instructions. Additionally, the available bits, a_ available, b_ available, and c_ available, are set when the operand is dependent upon another instruction, but certain situations exist. For example, in a first such situation which involves an "a" operand, the a_available bit will be set when the "a V" bit is negated or an instruction satisfying the dependency is operating in the e3 stage of an appropriate one of FPU pipe 0 310 and FPU pipe 1 312. The mechanism described above provides a precise out-of-order issue mechanism which efficiently and effectively handles several multiple dependencies among different fpu rr instructions within a three instruction window. The mechanism is, however, not precise between instructions outside the three instruction window. For these cases, dependent instructions may be eagerly issued occupying issue slots though their dependencies persist. In these cases, hold logic precisely determines whether the issuing instruction can truly execute and holds the instruction in the queue until the following cycle if the instruction cannot execute. Furthermore, a less precise mechanism may also be implemented to select issuance, in which the hold circuitry again maintains architectural compliance at the expense of wasted issue cycles. For instance, assume the issue bits provided to both FPU pipe 0 310 and FPU pipe 1 312 are asserted. Subsequently, hold logic (not illustrated herein) may be used to recognize that the operands are not available for execution and the instruction should be held in the queue until the operands become available. In such a situation, an instruction that could have issued out-of-order would be preempted from issue by the instruction that was erroneously thought to be available for issue, but could not truly execute. In fact, the above-described mechanism is often dependent upon such hold logic. For example, instructions that are dependent upon load instructions do not recognize dependencies in terms of scheduling for issue. Therefore, issue bits associated with instructions dependent upon load instructions are asserted and such instructions are scheduled to be issued even though the load execution may not have executed. This scheduling will then take an issue slot in one of the pipes. In one embodiment of the present invention, two FPU units are implemented and, there are two issue slots available per cycle. In this situation, as many as four instructions at a predetermined location in the queue are considered for selecting two instructions to fill the two slots. One instruction will issue to one of the pipes and a second instruction will issue to the other pipe. The issue slot is represented by outputs of Table 1. Note that only two of the eight outputs of Table 1 are asserted for a given input line. The inputs are the issue bits of Table 1 determined by the FPU rename and decode logic 302 described in FIGURE 4. The issue bits frame four queue positions (AIQ0-AIQ3). The four queue portions are shown as inputs to Table 1 with two issue bits per queue position. Furthermore, each queue position is associated with one instruction, and the two issue bits for a queue position indicate whether that instruction is ready for issue to FPU pipe 0 310 or FPU pipe 1 312. When both issue bits are asserted, the instruction is ready for issue to either of FPU pipe 0 310 or FPU pipe 1 312. For example, consider the line denoted with an "*" in Table 1. At this point in Table 1, an instruction in the AIQ0 queue position can't issue to either FPU pipe 0 310 or FPU pipe 1 312. Rather, this instruction is dependent upon an instruction that has yet to execute to a stage of a pipe to clear its dependency. The instruction in the AIQ1 queue position can issue to FPU pipe 0 310, the instruction in the AIQ2 queue position can issue to FPU pipe 0 310, and the instruction in the AIQ3 queue position can issue to either pipe. As the output of the table indicates, the instruction in the AIQ1 queue position is selected to issue to FPU pipe 0 310 and the instruction in the AIQ3 queue position is selected to issue to FPU pipe 1 312. Thus, the instruction in the AIQ1 queue position takes the issue slot to FPU pipe 0 310 and the instruction in the AIQ3 queue position takes the issue slot to FPU pipe 1 312. Assuming neither of these instructions are held by hold logic, they are removed from the queue during the current cycle. Otherwise, the held instruction, as well as the instruction, not selected for an issue slot, remain in the queue to be considered for filling an issue slot in the subsequent cycle. Refer again to the line denoted with a "*" in the left margin of Table 1. The instruction at the AIQ1 queue position was chosen over the instruction at the AIQ2 queue position to take the issue slot to FPU pipe 0 310 because it was earlier in the instruction sequence. These conditions are expected to be infrequent due to the short load latency with respect to the FPU pipes implemented herein, load instruction slippage ahead of dependent instructions via register rename and queuing, and the pre-fetch of FPU data. A third part of the mechanism maintains the two issue state bits of FPU pipe 0 310 and FPU pipe 1 312 once the instruction is placed in FPU instruction queue 304. The issue bits for a given instruction arrive to FPU instruction queue 304 from FPU rename and decode logic 302. The issue bits may have the following states: 1. Neither issue bit to either pipe is asserted; 2. Issue bit to FPU pipe 0 310 is asserted, while issue bit to FPU pipe 1 312 is unasserted; 3. Issue bit to FPU pipe 0 310 is unasserted, while issue bit to FPU pipe 1 312 is asserted; and 4. Both issue bits are asserted. When both issue bits are asserted, an instruction is ready for issue to either pipe with no restrictions. Such a state occurs either because the instruction is independent of fpu rr instructions or all of the instructions dependencies have been cleared, satisfied outside the dependence window, or dependent upon a load. Once in this state, the issue bits remain in this state until the instruction is issued. When one of the issue bits is asserted, and the other issue bit is unasserted, dependent data can be forwarded to the "b" operand, "c" operand, or both in a following cycle when an instruction is issued to a matching pipe in the issue cycle. This operation may occur only if the instruction is issued to a pipe whose issue bit is asserted. If the instruction is retained in FPU instruction queue 304 for an extra cycle, the dependent data can be forwarded to a "b" operand, "c" operand, or both from either of the pipes, as the preferred embodiment supports cross-pipe forwarding into the e0 stage of the pipe for each of the "a" operand, "b" operand, and "c" operand values. Therefore, any position within FPU instruction queue 304 in either state 2 or 3, should assert both issue bits in a following cycle, if the instruction is retained in the queue. Thus, the issue bit to a given pipe is set for a next cycle when the issue bit of the other pipe is asserted in the given cycle. Therefore, states 2 and 3 denoted above, go to state 4 after residing in the queue for one cycle if the instruction is retained in FPU instruction queue 304. Lastly, consider an instruction entering the queue in which neither issue bit is asserted. This indicates that the instruction must be retained within the queue for an additional cycle since it cannot issue the following cycle. State 1 must transition to either of states 2, 3 or 4 before being issued. The instruction will transition to either state 2 or 3 if it has a "b" operand or "c" operand dependency on an instruction in the e2 execution stage of pipe 0 or pipe 1, respectively, but has no dependency on another instruction that has not executed. For example, if instruction i1 has a "b" operand dependency upon instruction i0, and the "a" operand and "c" operands are independent, then instruction i1 transitions from state 1 to state 2 when instruction i0 is in the e2 execution stage of FPU pipe 0 310 and from state 1 to state 3 if instruction i0 is in the e2 execution stage of FPU pipe 1 312. Consider another example in which instruction i2 has a "b" operand dependency upon instruction i1, which is in the e2 execution stage of FPU pipe 0 310. Additionally, the "c" operand of instruction i2 is dependent upon instruction i0, which is in the e2 stage of FPU pipe 1 312. In this instance, the instruction should remain in state 0. However, the "b" operand and "c" operand are marked as available for a next timing cycle and the b_available and c_available bits are set in FPU instruction queue 304. In a second timing cycle, the a_available bit (assuming that the "a" operand is independent), the b_available bit, and the c_available bit are all asserted to set the issue bits for both pipes for the subsequent cycle. In this subsequent cycle, both issue bits are asserted, and the dependent instruction can issue to either FPU pipe 0 310 or FPU pipe 1 312 since instruction i0 and instruction i1 are in the same write back (WB) cycle and can be forwarded to the "b" operand from FPU pipe 0 310 and to the "c" operand from FPU pipe 1 312. The out-of-order issue mechanism also implements logic which receives eight issue bits, two from each of the bottom four queue positions of FPU instruction queue 304. This logic determines which two of the four instructions should be issued to each of FPU pipe 0 310 and FPU pipe 1 312. This logic is implemented as issue logic 306. Issue logic 306 prioritizes queue positions for issue from bottom to top, wherein the bottom indicates a highest priority and the top indicates a lowest priority. In this prioritization scheme, if two instructions with equal issue requirements contend for a slot in either of FPU pipe 0 310 or FPU pipe 1 312, the bottom position will preempt the higher position. Issue logic 306 has a truth table as set forth in Table 1. As may be observed from Table 1, the issue bits are used to intelligently issue the instructions to FPU pipe 0 310 and FPU pipe 1 312 in a manner in which three cycle forwarding of the "b" operand and "c" operand can be effectively utilized. As is observed from the discussion provided above, the preferred embodiment provides a mechanism for removing instructions from an instruction queue as soon as possible. Thus, the queue is free to allow dispatch of subsequent instructions from I-cache 202 and instruction unit/branch unit 204. This increases the possibility that other instructions for other functional units will be dispatched and, therefore, increases the chance of keeping all functional units within CPU 110 busy, while allowing cache miss operations for load operations to slip ahead of dependent instructions. A more detailed description of operation of the preferred embodiment will be provided in the subsequent discussion referencing the flow charts illustrated in FIGURES 7-1 through FIGURES 10-11. Description of Flow Charts The flow charts provided herein are not indicative of the serialization of operations being performed in the preferred embodiment of the present invention. Many of the steps disclosed within these flow charts are actually performed in parallel. The flow chart is only meant to designate those considerations that must be performed to produce the operation available on issue bits for an instruction. Referring now to FIGURE 7-1, operation is initiated when an instruction is provided from I-cache 202 to instruction unit/branch unit 204. Thereafter, instruction unit/branch unit 204 dispatches the instruction. Subsequently, instruction unit/branch unit 204 determines whether the instruction, labeled i0, is a fpu rr instruction by evaluating the opcode of the instruction provided by I-cache 202. If the instruction is a fpu rr instruction, instruction target detect logic 406 of FPU rename and decode logic 302 of floating point unit 210 determines whether instruction i0 has an fpr target. The fpr target indicates an FPR location that will be accessed. If instruction i0 has an fpr target, a location in a rename buffer (not illustrated herein) is allocated to the fpr target by rename logic 402 for temporarily storing the results of the instruction's execution prior to the instruction being completed. When the instruction is completed, the results are moved to an architected fpr at the locations specified by a target designator of the instructions and the rename buffer is deallocated and freed for use by subsequent instructions. Once the presence or absence of the fpr target is established and a buffer is allocated to the present target designators, the source operands are extracted to be used to determine when a dependency on a fpu rr instruction exists. This information is then utilized to set available bits and instruction issue bits, in accordance with FIGURES 7-6 through 7-14. If, after the instruction is dispatched, the rename and instruction decode logic of FIGURE 4 determines that instruction i0 is not a fpu rr instruction, but is a FPU load instruction, a target of that load instruction is compared with the target of M1 history register 426. If the two are equal, the M1 history register target value is invalidated for an "a" operand and a corresponding "b" or "c" operand dependency check. Additionally, a target of instruction i0 is compared with the target of M2 history register 420. If a target of instruction i0 equals a target of M2 history register 420, an M2 target is invalidated for an "a" operand and a "b" or "c" operand dependency check. This step is referred to as the previously mentioned "breaking" of a dependency. For any dispatched instruction, the targets of the intervening dispatched instructions are compared with the targets of the history state to invalidate dependency checking for that instruction. For example, assume the fpr of history state M1, (i.e. block 426 of FIGURE 4) is a hexadecimal value of $15, and that M1's "aV" value (428) and "bc V" value (430) are both asserted. Consider then that an instruction sequence is: 1fd $15 ← mem (64 + 8), and then fadd $7 ← $15 + $8, is dispatched. The aop source of the dispatched fadd ( i.e. $15) matches the history state M1 in block 426 to indicate that the aop is dependent upon the execution of the instruction whose history is saved in the M1 history state. Because M1's "aV" value (428) and "bc V" value (430) are asserted, the instruction has not executed. The failure to execute causes the a_available signal corresponding to the fadd instruction to be unasserted and the issue bits to be negated. This dependence, however, is false due to the intervening load (lfd) instruction to $15. In this instance, the fadd instruction is actually dependent upon the load rather than the instruction whose history is retained in M1 history state registers. Because load operations are assumed to slip ahead in the preferred embodiment, the a_available and the issue bits for the fadd instruction should be asserted. These values may be asserted by resetting the M1 history state registers "aV" and "bc V" bits. Returning again to FIGURES 7-1 and 7-2, if a target of instruction i0 does not correspond to a target of M2 history register 420, each of the aforementioned steps 702-718 is repeated for a next instruction, i1. This repetition is illustrated in FIGURE 7-2. Additionally, if instruction i0 is not a FPU load instruction and is not a fpu rr instruction, steps 704-718 are repeated for the next instruction, i1. Additionally, as is illustrated in FIGURE 7-3 and FIGURE 7-4, each of steps 702-718 is respectively repeated for instructions i2 and i3. However, if it is determined that instruction i3's target does not correspond to a target of M2 history register 420, the steps in FIGURE 7-5 are executed. As illustrated in FIGURE 7-5, it is next determined whether a buffer pointer of either FPU pipe 0 310 or FPU pipe 1 312 equals a buffer pointer of M1 history register 426. If the two correspond to one another, the "bc V" bit stored in one register 430 is negated. If the buffer pointer in the e2 stage of FPU pipe 0 310 and FPU pipe 1 312 is not equal to the M1 history register 426 buffer pointer, it is next determined whether an e2 target buffer pointer of either FPU pipe 0 310 or FPU pipe 1 312 equals a buffer pointer of M2 history register 420. If the two do equal one another, the "bc V" bit of M2 register 424 is negated. If not, a program flow returns to step a1 and step 702 of FIGURE 7-1. After the steps in FIGURE 7-1 through 7-5 have been completed and the "a" operand, "b" operand, and "c" operand values are assigned, an order of instruction operation is determined. In each of FIGURE 7-6 through 7-13, the state of the issue bits and available bits for a first dispatched fpu rr instruction are determined. Refer now to FIGURE 7-6. As illustrated in FIGURE 7-6, when an aop of instruction i0 is equal to a value stored in an M1 target, then it is determined whether a target buffer pointer found in an e3 stage of pipeline p0 is equal to a target buffer pointer of the M1 history register 426. If the two are equal, a program flow goes to a program entry point referred to as B7. The B7 program entry point is found on FIGURE 7-9. There, in step 790, a bop corresponding to instruction i0 is compared with a target register in M1 history register 426. If the two are equal, a target buffer pointer of the e2 stage of pipeline p0 is compared with the target buffer pointer of M1 history register 426. If the two are equal, a cop of instruction i0 is compared with a target in M1 history register 426. If the two are equal, a target buffer pointer to the e2 stage of pipeline p0 is compared with a target buffer pointer of M1 history register 426. If the two are equal, a program flow goes to a program entry point labeled B12. The program entry point labeled B12 is found in FIGURE 7-13. There, an iss_to_0 signal is asserted to indicate that the instruction being dispatched should be issued to fpu pipe 0 310. Additionally, an iss_to_1 signal is negated to indicate that the instruction being dispatched should be issued to fpu pipe 1 312. Additionally, each of the aop_available, bop_available, and cop_available signals are asserted to indicate that the instruction may be issued to either pipe after the subsequent cycle. It should be noted that a myriad of paths may be taken through the flow charts from FIGURE 7-6 through FIGURE 7-13 to determine a value of the issue bits and the available bits for the first dispatched fpu rr instruction. Each of these myriad of manners will not be described in detail herein, as to do so would be unduly confusing and burdensome to the reader. Therefore, the flow charts in each of FIGURES 7-6 through 7-13 are provided to indicate a manner in which the issue bits and available bits for a first dispatched fpu rr instruction may be determined. Next, in FIGURES 7-14 through 7-19, the sources of an instruction being dispatched are compared with targets in each of M1 history register 426 and M2 history register 420. During this operation, FPU rename and decode logic 302 determines when a dependency identified in the previous steps is cleared by the pipe. For example, assume that a fpu rr instruction accesses a same address location as a value stored in one of M1 history register 426 and M2 history register 420. However, during execution by one of FPU pipe 0 310 and FPU pipe 1 312, the address is freed. Thus, the dependency is then cleared in a corresponding one of the pipes. For one such operation, refer to FIGURE 7-14. It should be noted that additional operations are executed in each of FIGURES 7-15 through 7-19, but for the sake of clarity and brevity, only one of the many operations carried out in each of FIGURES 7-14 through 7-19 will be described in greater detail herein. However, it should be known that each of the steps disclosed in FIGURES 7-15 through 7-19 are executed in one embodiment of the present invention. Refer now to FIGURE 7-14 and a step 7140 therein. There, FPU rename and decode logic 302 determines when instruction i1 is a fpu rr instruction. If instruction i1 is a fpu rr instruction, it must next be determined whether instruction i1 has an fpr target in a step 7142. If instruction i1 has an fpr target, then a location in rename buffer 308 is allocated to the fpr target value in a step 7144. It should be noted that to get to step 7140, instruction i0 is an fpurr instruction and instruction i1 is checked as an fpu rr instruction. In reach step 7142, instruction i1 is also a fpu rr instruction. Therefore, instruction i1 is the second dispatched fpu rr instruction and instruction i0 is the first dispatched fpu rr instruction. Furthermore, each of the aop, bop, and cop values of instruction i1 are denoted as aop, bop, and cop, respectively, in the flowchart steps of FIGURES 7-20 through 7-25, and the instruction i0 is provided as pi in those steps. Next, in FIGURES 7-20 through 7-25, dependencies of the second dispatched fpu rr instruction are determined. As was performed with the first dispatched fpu rr instruction, the issue bits and available bits are determined to evaluate whether a dependency exists between a dispatched instruction and an instruction currently executing within one of FPU pipe 0 310 and FPU 1 312. As these determination steps have previously been described with respect to the first dispatched fpu rr instruction, they will not be described in greater detail herein. Reference should be made by the reader to the flow charts illustrated in FIGURES 7-20 through 7-25 for further details on execution of the steps for determining dependency of a second dispatched fpu rr instruction. FIGURES 7-26 through 7-33 perform a classification step to determine a pipeline to which a third fpu rr instruction should be allocated. Again, these classification steps are previously referred to in FIGURES 7-1 through 7-5 for the first dispatched fpu rr instruction. Therefore, these steps will not be described in greater detail as they have previously been described in explicit detail. FIGURES 7-34 and 7-35 illustrate the steps required to determine whether the third dispatched fpu rr instruction is interlocked with the first and second dispatched fpu rr instructions, dispatched in the same cycles. An example of operation will subsequently be provided. It should be noted that this example is provided for illustrative purposes only and only describes one of a myriad of operations which may be executed using the steps of the flow chart illustrated in FIGURES 7-34 and 7-35. Refer now to FIGURE 7-34. In the step 7340 of FIGURE 7-34, an aop of the third dispatched fpu rr instruction is compared with a target location within M1 history register 426. If the two are equal, a B operation of the third dispatched fpu rr instruction is compared with the M1 history register 426 to determine if it matches a target value stored therein in a step 7342. If not, the B operation is compared with M2 history register 420 to determine whether it matches a target value stored therein in a step 7344. If not, a cop of the third dispatched fpu rr instruction is compared with M1 history register 426 to determine if it matches the target value stored therein in step 7346. If yes, the iss_to_0 signal and the iss_to_1 signals are negated to indicate that the third instruction may issue to either FPU pipe 0 310 or FPU pipe 1 312. Additionally, the aop_available signal and the cop_available signal are both negated to indicate that the aop and the cop of the third dispatched fpu rr instruction may not be forwarded into a corresponding stage of a respective one of FPU pipe 0 310 and FPU pipe 1 312. However, because the bop of the third dispatched fpu rr instruction did not match a target value in either M1 history register 426 or M2 history register 420, the bop_available signal is asserted to indicate that the bop value of the third dispatched fpu rr instruction may be forwarded thereto. Lastly, the methodologies illustrated in FIGURES 7-36 through 7-41 are executed to complete operation of the preferred embodiment. Specifically, the steps illustrated in each of FIGURES 7-36 through 7-41 are executed to allocate locations within rename buffer 308 to M1 history register 426 and M2 history register 420, where required. Additionally, FIGURES 8 and 9 illustrate a methodology implemented to maintain FPU instruction queue 304 for both FPU pipe 0 310 and FPU pipe 1 312. The methodology implemented to maintain issue bits in FPU instruction queue 304 for FPU pipe 0 310 is illustrated in FIGURE 8, while the methodology used to maintain issue bits for FPU instruction queue 304 for FPU pipe 1 312 is illustrated in FIGURE 9. Refer now to FIGURE 8. After the issue bits have been determined in FIGURES 7-1 through 7-41, maintenance of the issue bits for each of FPU pipe 0 310 and FPU pipe 1 312 must be determined. In a first step 800, it is determined whether an issue bit indicates that an instruction would be issued to FP pipe 0 310. If not, it is next determined in a step 802 whether the instruction should issue to FPU pipe 1 312. If an issue bit to one pipe is on and an issue bit to the other pipe is off, then for that cycle, the instruction can be issued to the matching pipe to take advantage of the three-cycle forwarding implemented by the preferred embodiment. If the instruction does not issue in that cycle, then the instruction upon which the held instruction is dependent has progressed to where the result can be forwarded to either pipe. If the instruction in question should not issue to FPU pipe 1 312, step 804 next determines whether the aop of the instruction is available for execution. If not, it is next determined whether a target buffer pointer to the e3 stage of FPU pipe 0 310 (p0 e3 tgg bfr ptr) is equal to an AIQ frab value, where the AIQ frab value corresponds to the rename buffer from which the aop is to get its data. If the two values correspond to one another, the a_available signal is asserted in a step 810. Each of these steps is repeated for the bop and the cop of the instruction in question. Furthermore, it should be noted that each of these steps is repeated in the methodology illustrated in FIGURE 9 to determine which pipe is producing the dependent result to allow issue to only that pipe taking advantage of three cycle forwarding available for those operations. FIGURES 10-1 through 10-11 are provided to illustrate a methodology implemented by the Boolean function illustrated in Table 1. Conclusion The implementation described herein is provided by way of example only. However, many other implementations may exist for executing the functions described herein. For example, the mechanism disclosed herein has been described using an assumed central processing unit and floating point unit design. The detailed flow charts are representative of alternatives that may be included in a mechanism being disclosed in such an environment. However, the description within the stated environment is not intended to limit the present invention to the described characteristics, since the mechanism may be adjusted to function within other CPU/FPU design constraints. Additionally, it should be noted that a different partitioning of the logic may be required to satisfy some cycle time requirements. For example, in the embodiment illustrated herein, the logic shown in a dispatch section is partitioned to execute in a later timing cycle to meet cycle time constraints, since the dispatch valid signals reached the floating point unit late in the dispatch timing cycle. Such partitioning of a logic between timing cycles is a well-known tuning method to those experienced in the art of logic design. Therefore, it is well-known to those with skill in the art that the chosen partition is not meant to limit the scope of this disclosure. It will also be appreciated that in the foregoing description, numerous specific details have been set forth such as specific word or byte lengths, etc; these are exemplary only and are not essential elements of the present invention. Further details concerning timing considerations and the like and the specifics of well-known circuits have been omitted inasmuch as such details are not necessary to obtain a complete understanding of the present invention and are within the skills of persons of ordinary skill in the relevant art. It will further be appreciated that the terms "assert" and "negate" and various grammatical forms thereof, have been used herein to avoid confusion when dealing with the mixture of "active high" and "active low" logic signals. "Assert" is used to refer to the rendering of a logic signal or register bit into its active, or logically true, state. "Negate" is used to refer to the rendering of a logic signal or register bit into its inactive, or logically false, state. Additionally, a binary value has generally been indicated by a "%" symbol proceeding a value and a hexadecimal value indicated by a "$" symbol preceding a value.

Claims: A data processing system, comprising: input means (204) for receiving a plurality of instructions; a first execution unit (310); storage means (208) for storing a validity value wherein the storage means stores a plurality of validity values, each of the validity values correspondent to a respective of the instructions, in which a first one of the plurality of validity values selectively indicating a first one of a plurality of instructions may be issued to a first execution unit, characterised in that : a second execution unit, in which a second one of the plurality of validity values selectively indicating a second one of the plurality of instructions may be issued to the second execution unit. The data processing system of claim 1 wherein the first execution unit is a floating point execution unit (210). The data processing system of claim 1 or claim 2, further comprising storage means for storing a plurality of target values, wherein each of the plurality of target values corresponds to a respective one of the plurality of instructions. The data processing system of claim 3, further comprising an interlock logic circuit (404) coupled to the validity value storage means (208) and the target values storage means, for selectively enabling issuance of the first one of the plurality of instructions in response to a first portion of the plurality of target values and the validity value. The data processing system of any preceding claim, wherein the storage means stores a plurality of validity values, and a first one of the plurality of validity values corresponds to a first operand of the first one of the plurality of instructions. The data processing system of claim 5, further comprising: storage means for storing a previously dispatched instruction; and an interlock logic circuit coupled to the input means and coupled to the previously dispatched instruction storage means for generating an interlock detect signal in response to the first operand and a previously dispatched operand corresponding to the previously dispatched instruction. The data processing system of claim 6, wherein the interlock logic circuit is coupled to the validity value storage means for receiving the first one of the plurality of validity values, the interlock circuit generating a first interlock clear signal in response to the interlock detect signal and the first one of the plurality of data values. The data processing system of claim 7, wherein the plurality of validity values further comprises a second validity value corresponding to a second operand of the first one of the plurality of instructions. The data processing system of claim 8, wherein the interlock logic circuit compares the second operand of the first one of the plurality of instructions with a second previously stored operand of the previously dispatched instruction to provide the interlock detect signal. The data processing system of claim 9, wherein the interlock logic circuit logically combines the interlock detect signal and the second validity value to selectively generate a second interlock clear signal The data processing system of any preceding claim, further comprising: detection means (434) for asserting a first dependency indicated in response to detecting a dependency between the first one of the first plurality of instructions, and the second instruction, wherein the dependency occurs during an interval when the second instruction is executed by the first execution unit; and issue (436) means for selectively issuing the first one of the plurality of instructions to one of the execution units in response to the first dependency indicator. The data processing system of claim 11, further comprising clearing means (432) for resetting the first dependency indicator in response to the first dependency being cleared in a preselected timing cycle. The data processing system of claim 12 wherein the first execution unit is a pipelined execution unit. The data processing system of claim 13 wherein the clearing means resets the first dependency indicator in response to the first dependency being cleared in a preselected stage of a pipeline of the first execution unit. The data processing system of claim 14 wherein a second one of the first plurality of instructions is selectively issued during an interval when the first one of the first plurality of instructions is executed in the preselected stage of the pipeline of the first execution unit. The data processing system of any of claims 11-15 wherein a first data value is generated by the second instruction and accessed by the first one of the first plurality of instructions. The data processing system of claim 16, further comprising a forwarding logic circuit for selectively communicating a first data value, corresponding to the second instruction, to the first one of the first plurality of instructions. The data processing system of any of claims 11-17, further comprising an instruction issue state logic circuit coupled to the detection means, for enabling the first one of the first plurality of instructions to be issued to the first execution unit in response to the first dependency indicator. The data processing system of claim 18, wherein the instruction issue state logic circuit enables the first one of the first plurality of instructions to be issued during an interval when the second instruction is currently being executed by a preselected execution stage. The data processing system of claim 19, wherein the preselected execution stage is a write-back execution stage. A data processing system as claimed in any preceding claim, further comprising: a first execution unit for selectively executing a first plurality of instructions; and an instruction issue logic circuit for generating a plurality of issue bits, wherein a first preselected number of issue bits correspond to one of the first plurality of instructions and wherein the first preselected number of issue bits selectively enables the first instruction to be executed. The data processing system of claim 21, further comprising an instruction queue coupled to the instruction issue logic circuit for receiving the first preselected number of issue bits and for selectively providing the first instruction in response to the first preselected number of issue bits. The data processing system of claim 22, further comprising a logic circuit coupled to the instruction queue for selectively modifying a logic state of each of the first preselected number of issue bits in the instruction queue. The data processing system of claim 23, wherein the logic circuit selectively modifies each of the first preselected number of issue bits in response to a dependency condition in the first execution unit. The data processing system of any of claims 21-24, further comprising a second execution unit for executing a second plurality of instructions, wherein the first preselected number of issue bits selectively indicates the first instruction is executable by one of the first execution unit and the second execution unit. The data processing system of any of claims 21-24, further comprising a second execution unit for executing a second plurality of instructions, wherein the first preselected number of issue bits indicates the first instruction is not executable by one of the first execution unit and the second execution unit. The data processing system of any of claims 21-26 wherein the instruction issue logic circuit prioritizes a preselected number of the first plurality of instructions in response to a state of a corresponding number of issue bits of each of the preselected number of the first plurality of instructions. The data processing system of any of claims 21-27, wherein the instruction issue logic circuit selectively provides the plurality of issue bits to delay execution of the first instruction. The data processing system of claim 28, wherein the plurality of issue bits is selectively asserted to delay execution of the first instruction one clock cycle, wherein the plurality of issue bits is selectively asserted to pre-empt execution of the first instruction (in favour of a subsequently dispatched instruction). The data processing system of claim 29, wherein the first execution unit is a pipeline execution unit, and wherein a first data value is forwarded to a first execution stage of the first execution unit when execution of the first instruction in initiated by the first execution unit. The data processing system of claim 30 wherein the first data value is forwarded from a subsequent execution stage of the first execution unit. The data processing system of claim 31, wherein a previously issued instruction is executing in the subsequent execution stage of the first execution unit. The data processing system of any of claims 21-32, wherein the instruction issue logic circuit selectively provides the plurality of issue bits to pre-empt execution of the first instruction, wherein a subsequently dispatched instruction is issued when execution of the first instruction is pre-empted. A method for issuing instructions in a data processing system having a first execution unit, comprising the steps of: receiving a plurality of instructions; storing a validity value, wherein the step of storing the validity value comprises storing a plurality of validity values, in which each of the plurality of validity values corresponds to a respective one of the plurality of instructions; selectively enabling a first one of the plurality of validity values to indicate the first one of the plurality of instructions may be issued to the first execution unit; characterised in that : utilizing a second one of the plurality of validity values to selectively indicate a second one of the plurality of institutions may be issued to a second execution unit. The method of claim 34, comprising the step of: enabling the first execution unit to perform a floating point execution operation. The method of claim 34, comprising the step of: storing a plurality of target values, wherein each of the plurality of target values corresponds to a respective one of the plurality of instructions. The method of claim 36, comprising the steps of: generating a first signal in response to a first portion of the plurality of target values and the first one of the plurality of validity values; and selectively enabling issuance of the first one of the plurality of instructions to the first execution unit in response to the first signal. The method of claim 34, wherein the first one of the plurality of validity values corresponds to a first operand of the first one of the plurality of instructions. The method of claim 38, comprising the steps of: storing a previously dispatched instruction; and generating an interlock detect signal in response to the first operand of the first one of the plurality of instructions and a first operand of the previously dispatched instruction. The method of claim 39, comprising the step of: generating a first interlock detect signal in response to the interlock detect signal and the first one of the plurality of validity values. The method of claim 40, comprising the step of: providing a second validity value which corresponds to a second operand of the first one of the plurality of instructions. The method of claim 41, comprising the step of: enabling the interlock logic circuit to compare the second operand of the first one of the plurality of instructions with a second previously stored operand of the previously dispatched instruction to provide the interlock detect signal. The method of claim 34, comprising the steps of: storing a plurality of target values, wherein each of the plurality of target values corresponds to a respective one of the plurality of instructions; generating a first signal in response to a first portion of the plurality of target values and the first one of the plurality of validity values; and selectively enabling issuance of the first one of the plurality of instructions to the first execution unit in response to the first signal. A method, as claimed in any of claims 34 to 43, further comprising the steps of: detecting a dependency between the first one of the first plurality of instructions and the second instruction, wherein the dependency occurs during an interval when the second instruction is executed by the first execution unit; and selectively issuing the first one of the first plurality of instructions to one of the execution units in response to the detected dependency. The method of claim 44, further comprising the steps of: asserting a dependency indicator in response to the detected dependency; and resetting the dependency indicator in response to the dependency being cleared, wherein the dependency is cleared during a preselected timing cycle. A method as claimed in any of claims 34 to 45, further comprising the steps of: selectively executing a first plurality of instructions in a first execution unit; generating a plurality of issue bits using an instruction issue logic circuit, wherein a first preselected number of issue bits correspond to one of the first plurality of instructions; and selectively enabling a first instruction to be executed in response to the first preselected number of issue bits. The method of claim 46, further comprising the steps of: receiving the first preselected number of issue bits at an instruction queue; selectively providing the first instruction in response to the first preselected number of issue bits; and modifying the first preselected number of issue bits in the instruction queue during execution of the first plurality of instructions by the first execution unit. The method of claim 46, further comprising the steps of: selectively providing the plurality of issue bits from the instruction issue logic circuit to delay execution of the first instruction; selectively asserting the plurality of issue bits to delay execution of the first instruction one clock cycle.

Inventors: EISEN SUSAN ELIZABETH, PHILLIPS JAMES EDWARD, EISEN, SUSAN ELIZABETH, PHILLIPS, JAMES EDWARD
Applicants: IBM, INTERNATIONAL BUSINESS MACHINES CORPORATION
Application year: 1998
Main classification: G06F9
IPC codes: G06F9