JP5335440B2 - Early conditional selection of operands - Google Patents

Description

【Technical field】
[0001]
The present disclosure generally relates to techniques for processing instructions in a processor pipeline, and more particularly to early conditional operands from multiple operands based on conditions set by execution of previous instructions in the pipeline processor. With regard to selecting with.
[Background]
[0002]
Generally portable products such as mobile phones, laptop computers, personal data assistants (PDAs), etc. require the use of a processor that executes programs that support communication and multimedia applications. A processing system for such a product includes a processor, a source of instructions, a source of input operands, and a storage space for storing execution results. For example, instructions and input operands may be stored in a hierarchical memory configuration consisting of general purpose registers, such as a multi-level cache including instruction and data caches, and system memory.
[0003]
In order to provide high performance in program execution, a processor typically executes instructions in a pipeline that is optimized for the processing technology and applications used to manufacture the processor. In high performance processors, the speed of accessing operands from storage is often slower than the instruction execution speed of the processor. Thus, obtaining an instruction specifying an operand from the storage device can stall the processor for one or more cycles corresponding to the difference between the access time of the storage device and the clock cycle time of the processor. Furthermore, it is often done that an instruction specifies a source operand that is the result of the execution of a previous instruction. In a multi-stage execution pipeline, an instruction that requires a previous execution result must be stalled until execution of the previous instruction is complete. These stalls limit the performance of the processor.
DISCLOSURE OF THE INVENTION
SUMMARY OF THE INVENTION
[0004]
In some aspects, the present disclosure recognizes that it is generally advantageous to minimize the number of stalls that can occur when executing instructions. Therefore, it is desirable to implement a select operand instruction that helps to minimize stalls and avoid or minimize the use of branch instructions in programs such as programs that support communication and multimedia applications. obtain. Such improvements to the processor improve the performance and efficiency of the operation of the processor.
[0005]
Embodiments of the present disclosure apply to a method of pipeline operation. The method includes detecting an instruction specifying at least one operand selected from a group of at least two operands, at least one of which is in the pipeline Running (In flight). Another step then determines the operand selection criteria specified by the instruction. Once the selection criteria are determined, it is then evaluated to select at least one operand from a group of at least two operands. When at least one selected operand becomes available, the instruction can be delivered to execution without waiting for an unselected operand to become available.
[0006]
Another aspect of the disclosure relates to an apparatus for processing instructions in a pipeline processor. The apparatus includes an execution stage that executes instructions using input operand data required by each instruction in the plurality of instructions. A hold circuit is used to generate a hold for each instruction and the hold ends when all input operand data is received. If the device determines the operand data to select before completing the reception of the input operand data and determines that the selected operand data is available, Running Means for terminating the hold with respect to the selection criteria specified in the instructions.
[0007]
A more complete understanding of the inventive concepts and other features disclosed herein will become apparent from the following detailed description and the accompanying drawings.
[Detailed explanation]
[0008]
The present disclosure will now be described more fully with reference to the accompanying drawings, in which some embodiments of the disclosure are shown. However, this disclosure can be embodied in various forms and should not be construed as limited to the embodiments set forth herein. Rather, these embodiments are provided so that this disclosure will be accomplished and accomplished and will fully convey the scope of the disclosure to those skilled in the art.
[0009]
Computer program code or “program code” that is executed or performed to perform operations in accordance with the teachings of this disclosure is C, C ++, JAVA®, Smalltalk, JavaScript®, Visual Basic®. ), First written in a high level programming language such as TSQL, Perl, or various other programming languages. Programs written in one of these languages are compiled into the target processor architecture and convert high-level program code into native assembler programs. Target processor architecture programs may be written directly in native assembler language. Native assembler programs use an instruction mnemonic representation of machine-level binary instructions. Program code or computer readable media as used herein refers to machine language code such as object code whose format is understandable by a processor.
[0010]
FIG. 1 is a block diagram of an exemplary wireless communication system 100 in which embodiments of the present disclosure may be used. For illustrative purposes, FIG. 1 shows three remote units 120, 130, and 150 and two base stations 140. In general, it will be appreciated that a wireless communication system may have additional remote units and base stations. Remote units 120, 130, and 150 include hardware components 125A, 125B, and 125C, respectively, having processors that execute and execute program code in accordance with the present disclosure. FIG. 1 shows a forward link signal 180 from base station 140 to remote units 120, 130, and 150 and a reverse link signal 190 from remote units 120, 130, and 150 to base station 140.
[0011]
In FIG. 1, remote unit 120 is shown as a mobile phone, remote unit 130 is shown as a portable computer, and remote unit 150 is shown as a fixed location remote unit in a wireless local loop system. For example, a remote unit may be a handheld personal communication systems (PCS) unit, a portable data unit such as a personal data assistant, or a fixed position data unit such as a meter reading equipment. possible. Although FIG. 1 illustrates remote units according to the teachings of the present disclosure, the present disclosure is not limited to these exemplary illustrated units. For example, improved processing efficiency is generally a desirable feature for the majority of products that have an internal processor, not just the illustrated remote device. Improvements in the efficient execution of instructions can be obtained by having instructions that conditionally select source operands in a pipeline processor in accordance with the present disclosure.
[0012]
A processor typically uses a different set of instructions that operate on the operands specified by the instruction. Load, store, add, multiply, shift, select, AND, or OR instructions are examples of instructions that can be given in the instruction set architecture. . A select instruction is an example of an instruction, where an operand is conditionally selected from a choice of two or more operands, and the selected operand can be stored in a target register address. In order to efficiently execute the select instruction, the determination of which operand to select and the fetch operation are handled with the least amount of time lost due to processor stalls.
[0013]
FIG. 2A is a functional block diagram of an exemplary pipelined processor complex 200 in which conditional selection of operand functions may be used. The processor complex 200 includes a processor pipeline 202, an L1 instruction cache 204, an L1 data cache 206, and a memory hierarchy 208. Peripheral devices that may be connected to the processor complex are not shown for clarity. In accordance with the first embodiment of the present disclosure, processor complex 200 may be suitably used in hardware components 125A-125C to execute program code stored in memory hierarchy 208.
[0014]
The processor pipeline 202 includes five main stages: an instruction fetch stage 210, a decode stage 212, a register read stage 214, an execution stage 216, and a write back stage 218. One skilled in the art will know which of these stages can be divided into multiple stages to perform some of the associated functions, or the pipeline can include other stages that provide additional functions. I will. For illustration, some of the main stages are shown as one stage, but each may be divided into two or more stages for high speed design. For example, the execution stage 216 is divided into three sub-stages: execution A (executeA) 220, execution B (executeB) 222, and execution C (executeC) 224.
[0015]
Although one processor pipeline 202 is shown, the processing of instructions for conditionally selected operands is applicable to superscalar designs and other architectures that implement parallel pipelines. In another implementation, a processor that supports conditional selection of operand instructions may have fewer or more stages than processor pipeline 202. For example, a superscalar processor designed for a high clock rate can have two or more parallel pipelines, each pipeline including an instruction fetch stage 210, a decode stage to support the high clock rate. 212, register read stage 214, execute A stage 220, execute B stage 222, execute C stage 224, and write back stage 218 are split into two or more pipeline stages to provide an overall processor pipeline depth ( depth) can be increased.
[0016]
In the processor pipeline 202, the first stage is the instruction fetch stage 210. The instruction fetch stage 210 fetches an instruction to be processed by a later stage from the L1 instruction cache 204. If an instruction fetch misses in the L1 instruction cache 204, the instruction is fetched from the memory hierarchy 208, which may include a level 2 (L2) cache and main memory. The instructions may be loaded into main memory from other sources such as boot read only memory (ROM), hard drives, optical disks, or from an external interface such as the Internet.
[0017]
The instruction fetch stage 210 supplies each fetched instruction to the decode stage 212. The decode stage 212 may decode the instruction into a collection of control bits that are supplied to the next stage of the pipeline and support additional operations in the decoding related to execution of the fetched instruction.
[0018]
The general form of a select operand type instruction is used and executed in the processor pipeline 202, for example, to avoid branching and manipulate data before processing, as described below. Or you can merge the data. For example, loads, stores, arithmetic, logic, shifts, comparisons, bit manipulation instructions, etc. can be augmented with the addition of operand selection functions to conditionally process operand data. In a select operand load instruction and a select operand store instruction, the selection is made between at least two memory base addresses. These are stored in a general purpose register (GPR) file and are referred to as GPR register addresses. In a select add instruction, an operand is selected from a choice of at least two operands, and the selected operand is added to another operand. In the general form of a select operand instruction, one or a group of operands may be selected from a larger group of operands based on one or more selection criteria satisfied. The selected one or group of operands is provided to the execution path for further processing as indicated by the selected operand instruction. It should be noted that one or more criteria can be used as criteria for determining the selection. A subset of the general form of a select operand type instruction is a select instruction, where the operand is conditionally selected from two register operands, and the selected operand is stored at the target register address. Another form of select operand instruction is an instruction that specifies a selection from a register operand and an immediate value.
[0019]
Another example is a select operand instruction used to select a block of operands from a choice of two or more blocks of operands that may be used in a vector processor. Each block of operands is referenced by a field in the select operand instruction that contains a pointer at the beginning of the block. Further, the general selection criteria may specify more than two options that can be obtained from the multi-bit selection criteria. The selection criteria may specify which operands are selected from a larger group, the number of operands selected, or other selection mechanism specified by the processor's instruction set architecture.
[0020]
The conditions used to determine the choice of operands can be generated from condition flags set by the processor in the execution of various arithmetic, logic, and other functional instructions commonly specified in the instruction set architecture. For example, a negative (N) bit 226 indicates whether the execution result is negative for an instruction that affects the N bit. Zero (Z) bit 228 indicates whether or not the execution result is all zero for an instruction that affects the Z bit. A carry (C) bit 230 indicates whether or not the execution result relates to carry out for an instruction affecting the C bit. An overflow (V) bit 232 indicates whether or not the execution result overflows for an instruction that affects the V bit. These bits may be stored in a condition code (CC) register 234 or a flag register that may also be part of the program status register.
[0021]
The condition code bits can be set by various stages of execution, but the program order of changing the condition code bits is maintained. For example, certain operations such as addition, logic operations, bit selection, address generation, etc. may be accomplished in the execution A stage 220. These execution A stage 220 instructions are also designated to affect the condition code register 234, and the affected condition code bits may be sent via path 240 at the end of execution. More complex operations, such as those specified in arithmetic logic unit (ALU) operations using register shift instructions, can be divided into two separate operation steps. The first computation step is achieved in the execution A stage 220 and the second computation step is accomplished in the execution B stage 222. When the execution of the instruction in the execution B stage 222 is complete, changes to the condition code register 234 can be sent via path 242. Operations with more complex properties can be achieved using additional execution stages. For example, a multiply instruction may utilize three stages: an execution A stage 220, an execution B stage 222, and an execution C stage 224, to complete the multiplication operation. When the third stage is complete, the condition code register 234 can be affected again by the appropriate bits sent through path 244. Because the instructions can complete in a different order than the program order due to the difference in execution length, the bits in the condition code register 234 are set according to the program order. The function of controlling the setting of the bits of the condition register 234 is included in the CC control logic 246 for purposes of explanation.
[0022]
Processing of the selected operand instruction may begin at decode stage 212. Rather than waiting for all operands to be fetched before determining the state of the operand selection criteria, the decode stage first determines the operand selection criteria. In order to determine the operand selection criteria, the pipeline must be examined to determine if there are already instructions in the pipeline that can affect the operand selection criteria. Instructions that affect the condition code register can affect only one bit, all bits, or some combination of bits in the register, so that the operand selection criteria specified by the selected operand instruction is decoded and the condition code register Determine which combination of bits in is required. For example, if the previous result was zero due to the setting of Z bit 228, one operand is selected, and if the Z bit is not set, a different operand is selected. Operand selection when the previous calculation is positive nonzero, examines both N bit 226 and Z bit 228 to see if both are set to "zero". You can get by. The value of the condition code register 234 is forwarded by the condition code (CC) path 248 to the decode stage 212, the register read stage 214, and the execution A stage 220, where the condition code bits can be monitored. .
[0023]
When using a select operand instruction in the decode stage 212, there can be up to four additional instructions in the processor pipeline 202. Three of these four additional instructions can be in different execution stages. When multiple execution stages are processed simultaneously using instructions that can affect the same condition code bit, the order of the program of execution indicates which instruction takes precedence in setting the condition code bit . The last instruction that precedes the selected operand instruction and affects the condition code bits used in the operand selection criteria is determined by the look-ahead process.
[0024]
The look-ahead process also initiates decoding using control bits decoded from each instruction passing through the pipeline. Some of the control bits indicate the condition bits, if any, that the instruction affects. The control bits of each decoded instruction can examine each pipeline stage according to the instruction-specific operation through the pipeline to determine whether that operation stage affects the condition code register 234. . For example, the look-ahead may be operated as an OR of specific control bits at each pipeline execution stage. This approach is useful as a quick test when an instruction in the pipeline execution stage does not affect one or more associated condition bits. Since control bits are available at each execution stage of the pipeline, it can also determine when the condition register can be affected.
[0025]
When an instruction in the pipeline execution stage does not affect one or more associated condition bits, there is sufficient information that can be used to determine the operand selection criteria in the decode stage. Once it is determined which operand is selected, processing proceeds to the next register read stage 214, which is given control information and fetches only the selected operand.
[0026]
When at least one instruction in the pipeline execution stage affects one or more associated condition bits, processing proceeds to the next register read stage 214, which is given control information and selects Fetch all operands requested by an operand instruction. While all operands are fetched, the selection criteria determination is monitored. As described in further detail below, the selection criteria may be determined before all operands are fetched and can be used to reduce stall time.
[0027]
The register read stage 214 fetches the operand requested to be processed, for example, in the execution A stage 220. Operands may be fetched from a general purpose register (GPR) file 250 or from a forwarding network (not shown). The transfer network provides a fast path around the GPR file 250 to supply the resulting operands as soon as they are available from the execution stage. Even with a forwarding network, the resulting operands from the deep execution pipeline 202 can take 3 cycles, as in the processor pipeline 202, or in other implementations 4 or more cycles. During these cycles, instructions in the register read stage 214 that request the result operand data from the execution pipeline must wait until the result operand is available.
[0028]
Another example of a stalling situation that must be accounted for arises from the execution of a load instruction. If there is a miss in the L1 data cache 206, execution of the load instruction can take a significant number of cycles. The load instruction may use a register in the GPR file 250 to supply a base address and add an immediate value to the base address in the execution A stage 220 to generate a valid address. The effective address is sent to the L1 data cache 206 via the data path. If there is a miss in the L1 data cache 206, the data must be fetched from the storage hierarchy 208, which may include the L2 cache and main memory. During the cycle it takes to fetch data after an L1 data cache miss, such as the source operand Running The instruction that requests the load data of Running Is stalled in the pipeline until all operands become available. A stall can be considered to occur at the register read stage 214 or at the beginning of the execute A stage 220. When the mistake is resolved, the load data is transferred via path 254 to a write-back operation that may be considered part of the write-back stage 218. The operands can then be written to the GPR file and further sent to the transport network. As described below, the impact of stalls in the execution of selected operand instructions due to load operations can be minimized.
[0029]
It should be noted that in some processor pipelines, the selection criteria may be evaluated after access to the register file begins. In this case, if it is determined that the operand is unnecessary and has not yet been received, the operand is Running The instruction processing stops tracking, or the processor stops “listening” the forwarding network for a tag indicating that the operand is available. This procedure is a passive operation rather than a fetch operation. Either approach is feasible within the teachings of this disclosure.
[0030]
FIG. 2B is an exemplary decision table 265 that identifies conditions that determine when to stall the processor pipeline before entering the execution stage of the processor. The instruction in the pipeline to be evaluated is a select operand instruction that specifies a choice of one operand from two operand choices, operand A (operand A) and operand B (operand B). The availability of operand B and operand A are shown in columns 266 and 267, respectively. Table 265 is based on the scenario where the selection criteria determine the selection of operand A. If the operand is shown to be usable, no additional cycles are required to obtain the operand. The status of the selection criteria is shown in column 268. A fetch operation is instructed to obtain one or both operands that are not available, as shown in column 269. Operands may be usable without stalling the pipeline when given by the transport network or from a GPR file. When the selection criteria cannot be determined (not available), this is considered to be because there is at least one instruction in the pipeline that can affect the selection criteria. As shown in stall column 270, the pipeline is stalled when input to complete execution, including operands and selection criteria, is not available. The overall operational scenario is indicated by a table row.
[0031]
Line 271 indicates that neither operand A nor operand B is available, and that no selection criteria are available. The pipeline is stalled in the operand read stage, during which both operands are fetched and one or more selection criteria condition bits are monitored. Line 272 shows that the selection criteria are determined before both operands are available, in which case it can be seen that operand B is not needed. For example, in the scenario of line 271, if operand B fetching has begun, operand B fetching can be safely terminated. The pipeline is stalled in the read stage and waits for operand A to become available. As in the scenario in lines 273 and 275, if operand A or operand B becomes available before the selection criteria are determined, processing remains stalled in the read stage and the other operand becomes available. Or wait for the selection criteria to be determined so that the selection criteria can affect the operand fetch operation. As in scenario 277, the pipeline stall is after it has begun, but before both selection criteria are determined, if both operands are available or available, the process is stalled in the read stage. And wait for selection criteria to be determined. As in the scenario in line 274, after the read stall has begun, selection criteria are determined and operand A is available, but operand B is not available, the fetch of operand B is terminated and processed. Goes through the execution stage. When the process reaches a scenario such as line 274 without stalling, the input is available and processing proceeds through the execution stage, so a stall in the register read stage is not required. As in the scenario at line 276, after the read stall has started, the selection criteria are determined and operand B is available, but operand A is not available until operand A becomes available until The stall continues. If processing reaches a scenario such as line 276 without stalling, operand A is not available, so stalling is required at the register read stage. When both operands and selection criteria are available, pipeline stalls are unnecessary and processing proceeds through the execution stage.
[0032]
As taught herein, when a selected operand instruction begins execution and the selected operand is available, it waits for operand data even if the other unused operand is not available Skip the stall that is needed for it, or end the stall early. Stalls due to waiting for operands of the selected operand instruction are maintained until the selection criteria are determined and the selected operand is fetched and available.
[0033]
When the operand becomes available for processing, the execution stage is entered. In a select instruction that selects between two GPR file operands based on the selection criteria and stores the selected operand in the target GPR file address, the operation bypasses the execution stage and writes the selected operand to the write back stage. 218 and a forwarding network (not shown). There is usually a result transfer network (not shown) that transfers the results of each execution stage to the subsequent instruction through the pipeline. In a general select operand instruction, the selected operand is passed to the execution A stage 220 and processing of the execution stage begins.
[0034]
Each execution stage may complete processing of the instruction or process only a portion of the requested operation, depending on the complexity of the operation specified by the instruction. As each execution stage completes its operation, the result may be sent directly to the write-back stage 218. For example, if the instruction completes its designated operation at the end of execute A stage 220, the result may be transferred to write back stage 218 via path 252. Similarly, an instruction that completes its operation at the end of execution B stage 222 transfers the result to write-back stage 218 via path 258, and an instruction that completes its operation at the end of execution C stage 224 results in a path 260. Is transferred to the write back stage 218. The write back stage 218 writes back the result to the GPR file 250 of the register. The results can be received at the write back stage 218 out of order compared to the order of the program, so that the write back stage 218 can take advantage of the processor capabilities when writing the results to the GPR file 250. Use and keep program order.
[0035]
When using packed data processing, select operand type instructions can be extended by the use of additional flags. For example, a set of flags may be byte-based, greater than or equal (GE) flags, less than flags (LE), or other conditional indications when processing packed data. indication, CI). In the 32-bit data type, four CI flags can be used. For the 64-bit data type, 8 CI flags can be used.
[0036]
FIG. 2C is a functional block diagram of a pipeline processor complex 280 in which a packed data select operand instruction may be used according to a second embodiment of the present disclosure. Pipeline processor 282 uses one or more selection criteria based on CI flag 284 that supports packed 32-bit operands. CI flag 284 is a program status word and may be included as a combined CC / CI register 288 along with a condition code register 286.
[0037]
A packed data select operand instruction can use the CI flag to select a byte from two packed data operands. For example, 32-bit packed data selection instructions may be specified to use individual CI [3: 0] flags in the instruction set architecture. The CI [3: 0] flag is 1, which selects the corresponding byte from operand A, and when it is zero, selects the corresponding byte from operand B. CI [3: 0] = 1010 selects byte 3 from operand A, selects byte 2 from operand B, selects byte 1 from operand A, selects byte 0 from operand B, and the selected byte Is generated as a 32-bit target register. When CI [3: 0] = 1111, all bytes of operand A are selected. When CI [3: 0] = 0000, all bytes of operand B are selected. Under the condition of CI [3: 0] = 1111, operand B is unnecessary and need not be fetched. Under the condition of CI [3: 0] = 0000, operand A is unnecessary and need not be fetched. The selection criterion is determined by the bit setting of the CI flag in the program status word. Selection criteria may be used based on CI flags that are all ones or all zeros to determine whether to fetch operands or suppress operand fetching.
[0038]
By using hold circuits such as hold circuit 262 of FIG. 2A and hold circuit 290 of FIG. 2C, stalls in the processor pipeline can be generated. The hold circuit can generate a hold signal and use the hold signal to, for example, gate pipeline stage registers to stall instructions in the pipeline. In the processor pipeline 202 of FIG. 2A and the pipeline 282 of FIG. 2C, when not all inputs are available in the register read stage, the hold signal is activated and the pipeline is held until the input arrives. The When all operands are available and the selection criteria are determined, the hold signal is released. For example, the hold signal can be appropriately activated or released according to an operation scenario as specified in the table 265 of FIG. 2B.
[0039]
Processing of the selected operand instruction involves determining the type of instruction, examining condition codes and flags, eg, CI flags, indicating conditions and flag states, and determining selection criteria. An instruction may have a field in the instruction format that indicates that it is a selected operand instruction. The teachings of this disclosure are applicable to various instruction format and architecture specifications.
[0040]
FIG. 3 is a general format of a 32-bit instruction 300 that specifies a conditional operand selection function in accordance with the teachings of this disclosure. The selected operand instruction 300 includes an opcode 302 that identifies the instruction as a selected operand instruction, and at least two source operand address fields Ra304 and Rb306. The opcode 302 specifies both a selection criterion and an instruction operation, and the instruction operation is, for example, addition, multiplication, shift, logic, bit operation, and the like. Instead, one or more separate bits may be specified in the instruction format to identify an opcode used only for function specification and an instruction as a select operand instruction. The other bit fields 308, 310, and 312 may be instruction designation fields for use in condition fields, target register address fields, data types, etc. that control whether instructions are executed or not executed.
[0041]
FIG. 4 is a flowchart 400 illustrating the computational steps required to conditionally select operands early in the processor pipeline. In step 404, the fetched instruction is decoded in a decode stage, such as decode stage 212, for example. In step 406, it is determined whether the instruction is a selected operand instruction. If the instruction is not a selected operand instruction, the process moves to step 408. In step 408, all of the operands are accessed from the general register file, such as GPR file 250, to the register read stage 214 as appropriate. If it is determined in step 410 that the operand is not immediately available, the instruction must be stalled and wait for all of the operands, as indicated in step 412. If step 410 determines that all operands are available, the instruction is allowed to proceed through the execution pipeline at step 414, for example, starting from execution stage 220 of FIG. 2A.
[0042]
Consider another scenario where the selected operand instruction is fetched and decoded in step 404. In this case, in step 406, the fetched instruction is determined to be a selected operand instruction, and the process moves to step 416. In step 416, a test is performed to determine whether operand selection criteria can be determined based on the current state of a condition code register, such as CC register 234 of FIG. 2A or CC / CI register 288 of FIG. 2C. Is called. In the pipeline Running The selection criteria cannot be determined when the previous instruction or the previous instruction affects the condition flag and thus can affect the operand selection criteria. When the operand selection criteria can be determined based on the current state of the CC or CI register, the process moves to step 418. In step 418, the operands selected based on the selection criteria are fetched. The process then proceeds to step 420 where, for example, the register read stage 214 is reached. In step 420, it is determined whether the selected operand is available. If it is determined in step 420 that the selected operand is not immediately available, the instruction must be stalled and wait for the selected operand, as indicated in step 422.
[0043]
If step 420 determines that the selected operand is available, processing proceeds to step 424 where the instruction is a subset of the general select operand instruction type or a general select operand instruction. To determine whether it is a select instruction of type If the instruction is a select instruction, processing proceeds to step 426 where an execution stage such as execution stage 216 is bypassed and the operand is transferred to a write back stage such as write back stage 218. The operand may further be sent to the transport network. When the instruction is a general select operand instruction, processing proceeds to step 414, for example, by starting from execution stage 220.
[0044]
The test in step 416 is performed in the pipeline Running There may be a scenario where it is determined that the previous instruction or the previous instruction affects CC register 234 or CC / CI register 288 and thus may affect operand selection criteria. In this case, processing proceeds to step 430 where the process of fetching all operands begins and the condition flag is monitored for updates. In step 432, a test is performed to determine whether all CC or CI bits associated with the selection criteria determination have been updated. If the associated CC or CI bit has not been updated, processing returns to step 430 and fetching of all operands continues. If it is determined in step 432 that all relevant CC or CI bits have been updated, processing proceeds to step 434 where unnecessary operand fetching is stopped as determined by the selection criteria. The process then proceeds to step 420 where it is determined whether the selected operand is usable. If not, instruction processing must be stalled until it is determined that the selected operand is available, as indicated in step 422.
[0045]
If the selected operand is available, processing proceeds to step 424 to determine whether the instruction is a select instruction that is a subset of a general select operand instruction type or a general select operand instruction type. . If the instruction is a select instruction, processing proceeds to step 426 where an execution stage such as execution stage 216 is bypassed and the operand is transferred to a write back stage such as write back stage 218. The operand is further sent to the transport network. If the instruction is a general select operand instruction, processing proceeds to step 414, for example, by starting from execution stage 220.
[0046]
Although the present disclosure has been disclosed in the presently preferred context, it will be appreciated that the teachings can be adapted to various contexts according to the disclosure and the claims of the present invention.
[Brief description of the drawings]
[0047]
FIG. 1 is a block diagram of an example wireless communication system in which embodiments of the present disclosure may be used.
FIG. 2A is a functional block diagram of a pipeline processor complex in which conditional selection of operand functions may be used in accordance with the first embodiment of the present disclosure.
FIG. 2B is a decision table identifying conditions that determine when to stall the processor pipeline before entering the execution stage of the processor in accordance with the present disclosure.
FIG. 2C is a functional block diagram of a pipeline processor complex in which conditional selection of packed data operand functions may be used according to a second embodiment of the present disclosure.
FIG. 3 is a diagram of a general format of a 32-bit instruction specifying a conditional operand selection function in accordance with the present disclosure.
FIG. 4 is a flowchart of the operational steps required to conditionally initially select an operand in a pipeline according to the present disclosure.

Claims (20)

In the method of pipeline operation,
Detecting a current instruction specifying a group of at least two operands, wherein one operand is selected from the group of at least two operands based on a condition value affected by execution of a previous instruction; , At least one of the two operands is executing in the pipeline;
Determining operand selection criteria specified by the current instruction;
Evaluating the condition value to determine whether to satisfy the operand selection criteria for selecting the one operand from the group of at least two operands;
When the one selected operand is received, and to hand over the previous SL current instruction execution,
And to end the fetch of an operand that has not been selected from the group in response to the selection of said one of the operands,
Including methods. Determining the operand selection criteria includes
The method of claim 1, further comprising decoding the current instruction to determine at least one condition flag used as a basis for the operand selection criteria. Evaluating the condition value is
The method of claim 1, further comprising waiting for a condition flag specified by the operand selection criteria to be affected if the condition flag is specified by the previous instruction that is still executing. Evaluating the condition value is
The method of claim 1, further comprising looking ahead in the pipeline to see if at least one condition flag is affected as specified by the previous instruction.   The method of claim 1, wherein at least two operands are selected and the group includes at least three operands. The method of claim 1, wherein the current instruction specifies a function of the one selected operand.   The method of claim 6, wherein the function returns a calculation result based on the one selected operand.   The method of claim 1, wherein a block having at least two operands is selected from a group of blocks of operands, each of the blocks of operands having two or more operands.   The method of claim 1, wherein the operand selection criteria is based on a conditional indication of at least one packed data byte. In a method of processing a select operand instruction in a processor pipeline,
Decoding one or more selection criteria specified by the selected operand instruction in a decode stage of the processor pipeline;
Analyzing a condition flag affected by execution of a previous instruction, wherein the condition flag is specified by the one or more selection criteria;
If the condition flag analysis indicates that one operand is selected from the group of at least two operands specified in the selected operand instruction, terminating the wait for the unselected operand;
Executing the selected operand instruction with the one selected operand;
A method comprising: Analyzing the condition flag
If the condition flag is affected as specified by the previous instruction that is still executing, the method further comprises waiting for the condition flag specified by the one or more selection criteria to be affected. The method of claim 10.   The method of claim 10, wherein the group of at least two operands includes a register operand and an immediate operand. Executing the selected operand instruction comprises:
The method of claim 10, further comprising returning the function in which the result of the one selected operand. In a pipeline processor that processes instructions,
An execution stage for executing the current instruction using one operand data, wherein a condition-based value is determined by execution of a previous instruction, and the one operand data is the value from a group of at least two operands The condition criteria and the at least two operands are specified by the current instruction;
A hold circuit for generating a hold for the current instruction before execution of the instruction by the execution stage until reception of the one operand data in the execution stage is completed;
Means for ending the hold when determining that the one operand data is available without waiting for an unselected operand from the group to become available. 15. The pipeline processor of claim 14, wherein terminating the hold further includes terminating a fetch operation for the unselected operand that is not required for the current instruction to complete execution. A decoder for decoding each instruction of a plurality of instructions into control bits including a control bit designating a condition code representing the condition criterion;
A pipeline stage that tracks control bits for each stage throughout the pipeline;
The pipeline processor according to claim 14, further comprising:   The pipeline processor of claim 16, wherein the control bits are readable at each pipeline stage to determine whether an execution stage affects the condition code. The current instruction specifies a selected operand instruction, at least a 1-bit field specifying the condition criteria for selecting the one operand data from the group of at least two operands, and within the group of at least two operands 15. A pipeline processor according to claim 14, comprising at least a 1-bit field for each operand. The pipeline processor according to claim 18, wherein the current instruction further includes a bit field that specifies a function of the one operand data.   The pipeline processor of claim 18, wherein the at least one bit field for each operand indicates an address indicating a block of operand data elements.

Images