WO2002046885A2

WO2002046885A2 - Handling conditional processing in a single instruction multiple datapath processor architecture

Info

Publication number: WO2002046885A2
Application number: PCT/US2001/050992
Authority: WO
Inventors: John L. Redford
Original assignee: Chipwrights Design, Inc.
Priority date: 2000-11-28
Filing date: 2001-11-09
Publication date: 2002-06-13
Also published as: CN1486465A; DE01988453T1; WO2002046885A3; AU2002241759A1; TWI236622B; EP1348167A2; WO2002046885A9

Abstract

A processor enable (PE) state of a datapath (18a) during conditional processing is maintained by saving a current PE state of the datapath as an indication thereof before the conditional processing, and manipulating the indication during the conditional processing to reflect changes in the PE state of the datapath that may occur during the conditional processing. Where the conditional processing block is an if-then-else processing block, the PE state is saved during if-processing by storing the indication as a value representing the current PE state, and the manipulating includes changing the value based on the PE stage during the if-processing. The PE state is inverted, or not, prior to performing the else-processing based on whether the if-processing changed the PE state of the datapath. At the end of the conditional processing block, the saved PE state of the datapath is restored based at least in part on the value. An instruction set and an SIMD processor (18a..18d) for carrying out these steps are also provided. The instruction set also includes instructions that combine one or more of the PE saving and manipulating steps with a branch operation.

Description

HANDLING CONDITIONAL PROCESSING IN A SINGLE INSTRUCTION MULTIPLE DATAPATH PROCESSOR ARCHITECTURE

CROSS-REFERENCE TO RELATED APPLICATIONS This application is related to a copending application entitled BRANCH

HANDLING FOR SINGLE INSTRUCTION MULTIPLE DATAPATH PROCESSOR ARCHITECTURES, which was filed on the same day as this application and is incorporated herein by reference.

TECHNICAL FIELD This invention relates to handling conditional processing in a single instruction multiple datapath (SIMD) processor architecture.

BACKGROUND

Parallel processing is an efficient way of processing an array of data items. A SIMD processor is a parallel processor array architecture wherein multiple datapaths are controlled by a single instruction. Each datapath handles one data item at a given time. In a simple example, in a SIMD processor having four datapaths, each data item in a four data item array would be processed in a respective one of the four datapaths. During program execution in the SIMD processor, multiple datapaths may be enabled prior to encountering a conditional processing block, such as an if-then-else- processing block. Before executing the conditional processing block, the processor enable (PE) states of each of the datapaths, i.e., whether they are enabled or disabled, must be saved in case any of the datapath PE states is changed during execution of the conditional processing block. Further, upon exiting the conditional processing block, the PE states of the datapaths must be restored to the states that existed prior to entry of the conditional processing block.

One approach to handling the datapath PE states during conditional processing operations is to maintain the PE state of each datapath in a register stack. As the PE state of the datapath is changed during the conditional processing, the previous PE state is pushed onto the register stack. Upon completion of the conditional processing block, the datapath's PE state is restored to that which the datapath had prior to executing the conditional processing block, by popping that previous PE state off the register stack. If the conditional processing block contains multiple conditional operations (e.g., nested if-then-else-operations), the stack must contain multiple registers to save the datapath PE states during (and restore the datapath PE states after) the various conditional operations. It may be difficult for software to manage the stack during nested conditional operations, because of limitations in the number of parallel registers available for use in the stack.

SUMMARY

One general aspect of this invention features maintaining a PE state of a datapath during conditional processing, by saving a current PE state of the datapath as an indication thereof before the conditional processing, and manipulating the indication during the conditional processing to reflect changes in the PE state of the datapath that may occur during the conditional processing. In related aspects, the invention features an instruction set and an SIMD processor for carrying out these steps. Preferred embodiments may include one or more of the following features.

After the conditional processing, the saved PE state of the datapath is restored based at least in part on the indication. The saving, manipulating, and restoring steps are performed for each one of a plurality of datapaths in a SIMD processor that performs the conditional processing. In an illustrated embodiment, the conditional processing includes an if- processing statement. The saving step includes storing the indication as a value representing the current PE state of the datapath. The manipulating includes changing the value based on the PE state of the datapath during the conditional processing. The value is incremented if the PE state of the datapath is disabled during the saving. The value is not changed from an initial value if the PE state of the datapath is enabled during the conditional processing.

After the if-processing statement is performed, the saved PE state of the datapath is restored based at least in part on the value. The restoring comprises assigning the datapath to a disabled PE state if the value exceeds a threshold, and otherwise assigning the datapath to an enabled PE state. The value is changed (e.g., decremented) if the value exceeds the threshold. The conditional processing block may comprise a plurality of the if-processing statements. In this case, the saving, manipulating, and restoring steps are performed for each of the if-processing statements.

The conditional processing block can also include an else-processing statement. The manipulating step further comprises changing (e.g., inverting) or not changing the value prior to performing the else-processing statement based on whether processing of the if-processing statement changed the PE state of the datapath.

For example, if the saved PE state of the datapath was an enabled state and the processing of the if-processing statement changed the PE state to a disabled state, the manipulating includes changing the value to indicate the enabled state. If the saved PE state of the datapath was an enabled state and the processing of the if-processing statement did not change the PE state, the manipulating includes changing the value to indicate the disabled state. If the saved PE state of the datapath was a disabled state, the processing of the if-processing statement will not change the PE state, and thus the manipulating includes maintaining the value to indicate the disabled state.

In another aspect, the invention features instructions that combine one or more of the PE state saving and manipulating steps with a branch operation.

Among other advantages, the invention enables the datapath PE state to be accurately tracked (and correctly restored) with minimal hardware overhead, even when the conditional processing block includes many nested conditional operations. In particular, PE state is tracked for each datapath with a single register, thereby eliminating the need for a stack that is multiple registers deep to maintain the PE state. In addition, datapath PE state is saved, manipulated, and restored rapidly at the start of, during, and upon exiting, the conditional processing block. Combining one or more of the PE state saving and inverting steps with a branch operation greatly reduces software overhead and increases processing speed.

Other features and advantages of the invention will be apparent from the description and drawings, and from the claims.

DESCRIPTION OF DRAWINGS FIG. 1 is a block diagram of a single instruction multiple datapath (SIMD) processor. FIG. 2 is a flow diagram of a process for maintaining a PE state of a datapath in a SIMD processor during conditional processing.

FIG. 3 shows a table of program code utilizing SANE_PE, RESTORE_PE and FLIP_PE instructions. Like reference symbols in the various drawings indicate like elements.

DETAILED DESCRIPTION

Referring to FIG. 1, a single instruction multiple datapath (SIMD) processor 10 includes an instruction cache 12, control logic 14, a serial datapath 16, and a number of parallel datapaths labeled 18a, 18b, 18c, 18, ... 18n. The parallel datapaths 18 write to a memory 20. Each of the datapaths 18 has an associated processor enable (PE) bit 22 that represents the PE state of that datapath. Specifically, parallel datapath 18a is associated with a PE bit 22a, parallel datapath 18b is associated with a PE bit 22b, and so forth. When a PE bit is enabled, its associated parallel datapath is enabled and data items may be written by that parallel datapath. For example, if PE bit 22a is enabled, data items may be written by parallel datapath 18a; if PE bit 22b is enabled, data items may be written by parallel datapath 18b. If PE bit 22n is enabled, data items may be written by parallel datapath 18n. When a PE bit is disabled, its associated parallel datapath is disabled and data items may not be written by that parallel datapath.

In operation, the control logic 14 fetches an instruction from the instruction cache 12. The instruction is fed to the serial datapath 16 that provides the instruction to the datapaths 18. Each of the datapaths 18 is read together and written together unless the processor enable bit is disabled for a particular datapath.

When an instruction causes the SIMD processor 10 to execute a conditional processing block within the program code (e.g., a processing block that includes one or more if-then-else processing statements), the current PE state of each of the datapaths must be accounted for, so that if any of the PE states of the datapaths are altered during execution of the conditional processing block, the PE states can be restored upon the completion of the conditional processing block. Often, a conditional processing block contains multiple conditional processing operations, some of which may be executed during (i.e., nested within) the processing of other conditional processing operations. In order to assure proper operation, the PE state of each datapath must be saved prior to entering each nested conditional operation, and the saved PE state must be restored upon completing the conditional operation.

As discussed above, one type of conditional processing operation is an if-then- else-processing operation. As the PE states of datapaths are changed during if-then- else processing, an interesting phenomenon occurs. Specifically, once the PE state of a datapath is disabled, the PE state of that datapath never again becomes enabled during operations that comprise that if-then-else processing block. The present invention tracks the PE state of each datapath by providing and manipulating a PE state indication that exploits this phenomenon. In brief summary, when a datapath enters a conditional processing block, its PE state indication is set to a value that indicates the current PE state of datapath (enabled or disabled, as evidenced by the datapath's PE bit), and that value is stored (e.g., in a parallel register associated with the datapath). The current PE state is thereby saved as an indirect indication thereof. During processing of the if-then-else processing block, the value is updated, as necessary, based on the datapath's PE state during the conditional processing. When the datapath completes the if-then-else-processing block, the value is used to restore the datapath's PE state to the PE state that the datapath had prior to entering the if-then-else processing block. As a result, the datapath's PE state is accurately tracked, even through numerous, nested conditional processing operations, and is elegantly restored after each conditional operation (and, ultimately, after completion of the entire conditional processing block). Overhead is minimized, because a single register is used to store the PE state indication (i.e., the value), rather than devoting different registers to store the datapath PE state information for each nested conditional operation within the block. FIG. 2 illustrates a process 50 of maintaining the state of a datapath in SIMD processor 10 during an exemplary if-then-else conditional processing block. Preliminarily, the datapath's PE state indication (which is held in one of the datapath's parallel registers R, Fig. 1) is initialized (52) to a threshold value. A threshold value of -1 is used for purposes discussed below. If the datapath's PE state is disabled when the if-processing block is encountered (i.e., at the time that the PE state is saved) (54), the value is incremented (56). Otherwise, the value is not changed (as shown by line 58). During the if-processing, the datapath's PE state may or may not be modified, depending on the results of the if-processing (59). If the conditional processing block includes an else-processing block (60), the process determines whether to invert the datapath's PE state prior to performing the else-processing (62); when else-processing is not included in the conditional processing block, step 62 is skipped (64). During step 62, process 50 inverts the PE state of the datapath from the saved PE state (i.e., the PE state of the datapath prior to executing the if-then-else-processing block) if the PE state of the datapath was enabled prior to executing the if-then-else-processing block. If, however, the PE state was disabled prior to encountering the if-then-else processing block, it will remain disabled, and thus process 50 does not change it.

Upon completing the else-processing block (or the if-processing block if the conditional processing block does not include an "else" statement), process 50 restores the saved PE state (i.e., the current PE state of the datapath prior to the datapath encountering the conditional processing block). Process 50 enables the PE state if the value of the indication is less than zero (66); otherwise, the datapath's PE state is disabled. Finally, the value of the indication is decremented if the value is greater than or equal to zero (68), that is, if the value exceeds the -1 threshold.

The conditional processing block may include other conditional processing statements. For example, it may include additional if-then-else-processing statements or if-processing statements arranged in nested relationship. If so, the various steps of process 50 are performed for the conditional processing statements to which they apply. To implement the process 50 of FIG. 2, three instructions are provided that are inserted in the assembly code produced by a compiler during compilation of a program to be executed in SIMD processor 10. The three instructions are:

SANE_PE (P) RESTORE_PE (P) FLIP_PE (P) where P refers to a parallel register in SIMD processor 10 in which the datapath's PE state indication is stored. During the program compilation, the compiler inserts the SANE_PE (P) instruction (which implements steps 54-58 of process 50) prior to the start of an if-processing block (e.g., immediately prior to the "if processing statement), and inserts the RESTORE_PE (P) instruction (which performs steps 66 and 68) at the end of the if-processing block. If the program includes an else-processing block within the if-processing block, i.e., if-then-else processing, the compiler inserts the FLIP_PE (P) instruction (which implements steps 60-64) at the start of the else-processing block (e.g., immediately prior to the "else" processing statement), and inserts the RESTORE_PE (P) instruction at the end of the else-processing block.

The SAVE_PE (P) instruction increments the indicator stored in register P from its initial value of -1 if the datapath is in the disabled state (i.e., PE=0) at that time. Otherwise, the instruction does not change the value of the indication. As a result, by testing whether the value in the register is less than zero, one can determine whether the previous PE state of the datapath was the enabled or the disabled state.

The RESTORE_PE (P) instruction performs two functions. If the value of the PE state indication is greater than -1 (i.e., if the saved PE state of the datapath is the disabled state), the RESTORE_PE (P) instruction assigns the datapath to the disabled PE state; otherwise, the datapath is enabled. The RESTORE_PE(P) instruction also decrements the PE state indication value stored in register P if the value is greater than or equal to zero. Otherwise, the RESTORE_PE (P) instruction does not change the stored value of the PE state indication. In this manner, the value of the indication is not decremented below -1.

The SAVE_PE (P) instruction is always paired with a RESTORE_PE (P) instruction. As a result, a datapath that is in the enabled PE state prior to encountering the if-processing block is restored to the enabled PE state at the conclusion of the if- processing block, regardless of whether (or how) the PE state may have been changed during the execution of the if-processing block.

Consider, for example, a datapath that is in the enabled PE state when it reaches the if-processing block. Its stored state indication value is -1. Neither the SANE_PE (P) instruction nor the RESTORE_PE (P) instruction changes the stored state indication value. Thus, the value is still -1 at the end of the if-processing block, and the datapath is assigned the enable PE state upon exiting the if-processing block.

On the other hand, if the datapath was disabled upon encountering the if- processing block, the SANE_PE (P) instruction causes the state indication value to be incremented from

-1 to 0. At the end of the if-processing block, the RESTORE_PE (P) instruction causes the value to be decremented back to -1. Because the value was greater than zero, however, the datapath is assigned the disabled PE state upon exiting the if-processing block.

The FLIP_PE (P) instruction is used for the "else" part of an if-then-else processing block. The operation of the FLLP PE (P) instruction is based on the current PE state of the datapath and the saved PE state of the datapath. Simply put, if the execution of the "if statement disabled the datapath (i.e., changed the associated PE bit from 1 to 0), the FLIP_PE (P) instruction will re-enable the datapath (i.e., change PE back to 1). If, however, the datapath was already enabled when the "if statement was encountered (i.e., the saved PE=1), and the datapath is still enabled after the "if statement is executed, FLIP_PE (P) will disable the datapath (i.e., change PE to 0). Finally, if the saved PE state of the datapath is disabled (PE=0), the datapath will always continue to be disabled after the "if statement is executed. In this case, the FLIP_PE (P) instruction will cause the datapath to remain disabled (PE=0).

The operation of the FLIP_PE (P) instruction is summarized in the following table:

Referring to FIG. 3, a table 100 is presented showing an example utilizing the SANE_PE, RESTORE_PE, and FLIP_PE instructions in a conditional processing block 101 involving two if-processing operations 102 and 104, and one else-processing operation 106. In this example, if-processing operation 104 is nested within if- processing operation 102 and else-processing operation 106. The table includes a stub of program code 108 and the resulting assembly code 110 generated by a SIMD compiler (not shown). The table 100 illustrates the assembly code 110 and register manipulation for a SIMD processor 10 having four datapaths DPO, DPI, DP2, and DP3. In the table, PI and P2 are parallel registers that respectively store data used during execution of the conditional processing block. P3 is the register that stores the PE state indication values, and PE is the register (22, Fig. 1) that stores the PE bits of the individual datapaths.

In the example presented, prior to encountering conditional processing block 101, datapaths DPO, DPI and DP2 are enabled, while datapath DP3 is disabled. This is shown in line 111.

As described previously, the compiler inserts a SANE_PE (P3) instruction 112 before the first if-processing block 102, a SANE_PE (P3) instruction 114 before the second (nested) if-processing block 104, a RESTOREJPE (P3) instruction 116 upon exiting the second if-processing block 104, a FLIP_PE (P3) instruction 118 at the start of the else-processing block 106, and a RESTORE_PE (P3) instruction 120 at the end of the else-processing block 106. As shown in line 122, the data values stored in register PI are initially 1, 0, -1, and -1, respectively. As shown in line 124, register P2 is initially unused. Line 111 indicates the initial PE states of the datapaths, as described above. Line 127 illustrates the operation of SANE_PE (P3) instruction 112. Because DP0-DP2 are currently enabled, the values for those datapaths stored in P3 (line 126) are not incremented from their initial value of -1. But because DP3 is disabled, SANE_PE (P3) instruction 112 causes the value in P3 for DP3 to be incremented to 0.

Line 128 shows the operation of if-statement 102. Specifically, the PE state of the datapath (PE) is enabled if PI is greater than or equal to 0 and the datapath is currently in the enable state. For DPO and DPI, PI is greater than or equal to 0 and PE is enabled (line 111), so PE is enabled for both datapaths. For DP2 and DP3, PI is not greater than or equal to zero, so PE is disabled.

At line 130, P2 is set to 1 in DPO and DPI. Because DP2 and DP3 are disabled, the contents of P2 for those datapaths are not changed.

Line 132 shows the operation of SANE_PE (P3) instruction 114 for if- processing block 104. Because the current PE state of DPO and DPI (shown by line 128) is enabled, instruction 114 does not increment the value in register P3 for those datapaths. However, instruction 114 increments the value in register P3 for DP2 and DP3, because those datapaths are disabled. Line 134 shows the operation of if-statement 104. DPO remains enabled, but DPI becomes disabled. DP2 and DP3 remain disabled.

As shown in line 135, in the next operation, the value stored in P2 becomes 2 for DPO, but remains 1 for DPI because DPI is disabled. Lines 136 and 138 show the results of the operation of the RESTORE_PE (P3) instruction 118 located at the end of if-processing block 104. Recall that execution of the RESTORE instruction causes the datapath to be enabled (PE set to 1) if the state indication value is less than zero, and disabled otherwise, while also decrementing the state indication value if it is currently greater than zero. Applying those rules to the present example, datapath DPO remains enabled (PE=1), because its state, as saved by SANE_PE (P3) instruction 114, was enabled (as indicated by the -1 value in P3 shown by line 132). Because DPI was also enabled prior to encountering if-statement 104, datapath DPI is restored to the enable PE state by RESTORE_PE (P3) instruction 116. DP2 and DP3 remain disabled, because their PE states prior to if-statement 104 were disabled (as shown by line 132). In addition, the values in P3 for DPO and DPI are not changed from their current value of -1, and the values in P3 for DP2 and DP3 are decremented to -1 and 0, respectively. By comparing lines 128 and 136, it is seen that the PE states of DP0-DP3 are the same after exiting if-processing block 104 as they were upon entering if-processing block 104. Line 140 shows the effect of FLIP_PE (P3) instruction 118 on the PE states of the PE bits. Note that else-statement 106 is paired with if-statement 102. Thus, it is the PE states of the datapaths as saved by SAVE_P3 (PE) instruction 112 (shown in line 127) that are relevant. Because the saved PE states of DPO and DPI were enabled, and because DPO an DPI are currently enabled (as shown by line 138), FLIP_PE (P3) instruction 118 disables these datapaths. As a result, PE is changed to 0 for DPO and DPI (line 140).

On the other hand, the saved PE state of DP2 is enabled (as shown by the -1 value in line 127), and the current PE state of DP2 is disabled (indicated by PE=0 in line 138). Accordingly, FLLP_PE (P3) instruction 118 enables DP2 (sets PE=1 in line 140).

Datapath DP3 was disabled when its PE state was saved by SAVE_PE (P3) instruction 112 (line 127), and remains disabled (PEN), line 138). Thus, FLIP_PE (P3) instruction 118 maintains DP3 disabled. This is shown by PE=0 in line 142. Because only datapath DP2 is currently enabled, the operation specified in else statement 106 is performed by only datapath DP2. This is shown in line 142.

Lines 144 and 146 illustrate the results of performing RESTORE_PE (P3) instruction 120 at the end of conditional processing block 108. Because the current values of the PE state indications are -1 for DP0-DP2 (line 138), RESTOREJPE (P3) instruction 120 assigns DP0-DP2 to the enable PE state (PE=1, line 144), and does not change the indication values (line 146). That is, datapaths DPO and DPI are restored to the enable state, and DP2 is maintained in the enable state. On the other hand, because datapath DP3 was not enabled, RESTORE_PE (P3) instruction 120 maintains DP3 in the disabled PE state (PE=0, line 144), and decrements the P3 value for DP3 from 0 (line 138) to -1 (line 146).

By comparing lines 111 and 144, it is seen that the state of datapaths DP0-DP3 are the same at the end of the conditional processing block 108 as they were when conditional processing block 108 was encountered. The saving of PE state and the setting of the PE bits during conditional processing can be combined with a branch operation. This concept is discussed in more detail in the copending application. The following instruction is illustrative: if (SANE_PE (Pb), PE = Pa = 0) go to X This instruction handles all of the work needed for the "if statement. That is, SANE_PE (Pb) saves the current PE state of the datapath in register Pb in the mamier discussed above. The PE bit is set according to the contents of register Pa and if equal to zero, a branch is taken to destination X. For example, if all PE bits are set to zero, the datapaths branch around (i.e. skip) the remainder of the conditional processing block, because none of the datapaths are enabled to perform any further work on the conditional processing block.

Similarly, the FLIP instruction may be combined with a branch, for example, in the following instruction: if (FLIP_PE (Pb)) go to X This instruction will invert the PE bits in the manner discussed above, and will branch to destination X if none of them are set. In this way, the datapaths are routed around a subsequent "else" processing block if they are all in the disabled PE state.

Either or both branches may be made a function of whether the program code is deterministic. That is, if either branch is taken, by definition work is skipped and the program runs faster. If the programmer wants the program to always run in the same amount of time, regardless of whether the branch conditions apply (e.g., if the program code must meet real-time deadlines), he or she will set a deterministic bit (DET) in the processor's register set. Neither branch is taken if the DET is set, even if all datapaths' PE states are disabled.

Embodiments of the invention have been described. Nevertheless, it will be understood that various modifications may be made without departing from the spirit and scope of the invention. Accordingly, other embodiments are within the scope of the following claims.

Claims

WHAT IS CLAIMED IS:

1. A method of maintaining a PE state of a datapath during conditional processing, comprising saving a current PE state of the datapath as an indication thereof before the conditional processing, and manipulating the indication during the conditional processing to reflect changes in the PE state of the datapath that may occur during the conditional processing.

2. The method of claim 1 further comprising, after the conditional processing, restoring the saved PE state of the datapath based at least in part on the indication.

3. The method of claim 2 further comprising performing the saving, manipulating, and restoring steps for each one of a plurality of datapaths in a SIMD processor that performs the conditional processing

4. The method of claim 1 wherein the conditional processing includes an if- processing statement, the saving including storing the indication as a value representing the current PE state of the datapath.

5. The method of claim 4 wherein the manipulating includes changing the value based on the PE state of the datapath during the conditional processing.

6. The method of claim 5 wherein the manipulating includes incrementing the value if the PE state of the datapath is disabled during the saving.

7. The method of claim 4 wherein the manipulating includes not changing the value from an initial value if the PE state of the datapath does not change during the conditional processing.

8. The method of claim 4 further comprising, after the if-processing statement is perfomied, restoring the saved PE state of the datapath based at least in part on the value.

9. The method of claim 8 wherein the restoring comprises assigning the datapath to a disabled PE state if the value exceeds a threshold, and otherwise assigning the datapath to an enabled PE state.

10. The method of claim 9 further comprising changing the value if the value exceeds the threshold.

11. The method of claim 10 wherein the changing includes decrementing the value.

12. The method of claim 8 wherein the conditional processing block comprises a plurality of the if-processing statements, and further comprising performing the saving, manipulating, and restoring for each of the if-processing statements.

13. The method of claim 4 wherein the conditional processing block includes an else-processing statement, the manipulating further comprising changing or not changing the value prior to performing the else-processing statement based on whether processing of the if-processing statement changed the PE state of the datapath.

14. The method of claim 13 wherein, if the saved PE state of the datapath was an enabled state and the processing of the if-processing statement changed the PE state to a disabled state, the manipulating includes changing the value to indicate the enabled state.

15. The method of claim 13 wherein, if the saved PE state of the datapath was an enabled state and the processing of the if-processing statement did not change the PE state, the manipulating includes changing the value to indicate the disabled state.

16. The method of claim 13 wherein, if the saved PE state of the datapath was a disabled state, the manipulating includes maintaining the value to indicate the disabled state.

17. A computer instruction set for maintaining a PE state of a datapath during conditional processing, comprising an instruction that causes the datapath to save a current PE state of the datapath as an indication thereof before the conditional processing, and manipulate the indication during the conditional processing to reflect changes in the PE state of the datapath that may occur during the conditional processing.

18. The instruction set of claim 17 further comprising an instruction that causes the datapath to, after the conditional processing, restore the saved PE state of the datapath based at least in part on the indication.

19. The instruction set of claim 17 wherein the conditional processing includes an if-processing statement, the instruction further causing the datapath to store the indication as a value representing the saved PE state of the datapath.

20. The instruction set of claim 19 further comprising an instruction that causes the datapath, after the if-processing statement is performed, to restore the saved PE state of the datapath based at least in part on the value.

21. The instruction set of claim 19 wherein the conditional processing block includes an else-processing block, the instruction set further comprising an instruction that causes the datapath to change or not change the value prior to performing the else- processing statement based on whether processing of the if-processing statement changed the PE state of the datapath.

22. A SIMD processor comprising a plurality of datapaths, each of the datapaths being capable of maintaining a PE state thereof during conditional processing by executing one or more instructions that cause the datapath to: save a current PE state of the datapath as an indication thereof before the conditional processing, and manipulate the indication during the conditional processing to reflect changes in the PE state of the datapath that may occur during the conditional processing.

23. A computer instruction set for execution by a datapath during conditional processing, comprising an instruction that causes the datapath to save an indication of a current PE state of the datapath as an indication thereof before the conditional processing, 5 establish the PE state for the conditional processing, and branch around the conditional processing if the established PE state does not satisfy a condition in the instruction.

24. The instruction set of claim 23 further comprising an instruction that causes the datapath to o invert the established PE state if a selected event occurs, and branch around the conditional processing if the inverted PE state does not satisfy a selected condition.