Abstract:
Hardware and software techniques for interrupt detection and response in a scalable pipelined array processor environment are described. Utilizing these techniques, a sequential program execution model with interrupts can be maintained in a highly parallel scalable pipelined array processing containing multiple processing elements (PEs) and distributed memories and register files. When an interrupt occurs, interface signals are provided to all PEs to support independent interrupt operations in each PE dependent upon the local PE instruction sequence prior to the interrupt. Processing/element exception interrupts are supported and low latency interrupt processing is also provided for embedded systems where real time signal processing is required. Further, a hierarchical interrupt structure is used allowing a generalized debug approach using debug interrupts and a dynamic debuts monitor mechanism.

Description:
The present application claims the benefit of U.S. Provisional Application Ser. No. 60/184,529 entitled “Methods and Apparatus for Scalable Array Processor Interrupt Detection and Response” filed Feb. 24, 2000 which is incorporated by reference herein in its entirety. 
    
    
     FIELD OF THE INVENTION 
     The present invention relates generally to improved techniques for interrupt detection and response in a scalable pipelined array processor. More particularly, the present invention addresses methods and apparatus for such interrupt detection and response in the context of highly parallel scalable pipeline array processor architectures employing multiple processing elements, such as the manifold array (ManArray) architecture. 
     BACKGROUND OF THE INVENTION 
     The typical architecture of a digital signal processor is based upon a sequential model of instruction execution that keeps track of program instruction execution with a program counter. When an interrupt is acknowledged in this model, the normal program flow is interrupted and a branch to an interrupt handler typically occurs. After the interrupt is handled, a return from the interrupt handler occurs and the normal program flow is restarted. This sequential model must be maintained in pipelined processors even when interrupts occur that modify the normal sequential instruction flow. The sequential model of instruction execution is used in the advanced indirect very long instruction word (iVIW) scalable ManArray processor even though multiple processor elements (PEs) operate in parallel each executing up to five packed data instructions. The ManArray family of core processors provides multiple cores 1×1, 1×2, 2×2, 2×4, 4×4, and so on that provide different performance characteristics depending upon the number of and type of PEs used in the cores. 
     Each PE typically contains its own register file and local PE memory, resulting in a distributed memory and distributed register file model. Each PE, if not masked off, executes instructions in synchronism and in a sequential flow as dictated by the instruction sequence fetched by a sequence processor (SP) array controller. The SP controls the fetching of the instructions that are sent to all the PEs. This sequential instruction flow must be maintained across all the PEs even when interrupts are detected in the SP that modify the instruction sequence. The sequence of operations and machine state must be the same whether an interrupt occurs or not. In addition, individual PEs can cause errors which can be detected and reported by a distributed interrupt mechanism. In a pipelined array processor, determining which instruction, which PE, and which data element in a packed data operation may have caused an exception type of interrupt is a difficult task. 
     In developing complex systems and debugging of complex programs, it is important to provide mechanisms that control instruction fetching, provide single-step operation, monitor for internal core and external core events, provide the ability to modify registers, instruction memory, VLIW memory (VIM), and data memory, and provide instruction address and data address eventpoints. There are two standard approaches to achieving the desired observability and controllability of hardware for debug purposes. 
     One approach involves the use of scan chains and clock-stepping, along with a suitable hardware interface, possibly via a joint test action group (JTAG) interface, to a debug control module that supports basic debug commands. This approach allows access on a cycle by cycle basis to any resources included in the scan chains, usually registers and memory. It relies on the library/process technology to support the scan chain insertion and may change with each implementation. 
     The second approach uses a resident debug monitor program, which may be linked with an application or reside in on-chip read only memory ROM. Debug interrupts may be triggered by internal or external events, and the monitor program then interacts with an external debugger to provide access to internal resources using the instruction set of the processor. 
     It is important to note that the use of scan chains is a hardware intensive approach which relies on supporting hardware external to the core processor to be available for testing and debug. In a system-on-chip (SOC) environment where processing cores from one company are mixed with other hardware functions, such as peripheral interfaces possibly from other companies, requiring specialized external hardware support for debug and development reasons is a difficult approach. In the second approach described above, requiring the supporting debug monitor program be resident with an application or in an on-chip ROM is also not desirable due to the reduction in the application program space. 
     Thus, it is recognized that it will be highly advantageous to have a multiple-PE synchronized interrupt control and a dynamic debug monitor mechanism provided in a scalable processor family of embedded cores based on a single architecture model that uses common tools to support software configurable processor designs optimized for performance, power, and price across multiple types of applications using standard application specific integral circuit (ASIC) processes as discussed further below. 
     SUMMARY OF THE INVENTION 
     In one aspect of the present invention, a manifold array (ManArray) architecture is adapted to employ the present invention to solve the problem of maintaining the sequential program execution model with interrupts in a highly parallel scalable pipelined array processor containing multiple processing elements and distributed memories and register files. In this aspect, PE exception interrupts are supported and low latency interrupt processing is provided for embedded systems where real time signal processing is required. In addition, the interrupt apparatus proposed here provides debug monitor functions that allow for a debug operation without a debug monitor program being loaded along with or prior to loading application code. This approach provides a dynamic debug monitor, in which the debug monitor code is dynamically loaded into the processor and executed on any debug event that stops the processor, such as a breakpoint or “stop” command. The debug monitor code is unloaded when processing resumes. This approach may also advantageously include a static debug monitor as a subset of its operation and it also provides some of the benefits of fully external debug control which is found in the scan chain approach. 
     Various further aspects of the present invention include effective techniques for synchronized interrupt control in the multiple PE environment, interruptible pipelined 2-cycle instructions, and condition forwarding techniques allowing interrupts between instructions. Further, techniques for address interrupts which provide a range of addresses on a master control bus (MCB) to which mailbox data may be written, with each address able to cause a different maskable interrupt, are provided. Further, special fetch control is provided for addresses in an interrupt vector table (IVT) which allows fetch to occur from within the memory at the specified address, or from a general coprocessor instruction port, such as the debug instruction register (DBIR) at interrupt vector  1  of the Manta implementation of the ManArray architecture, by way of example. 
     These and other advantages of the present invention will be apparent from the drawings and the Detailed Description which follow. 
    
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
         FIG. 1  illustrates a ManArray 2×2 iVLIW processor which can suitably be employed with this invention; 
         FIG. 2A  illustrates an exemplary encoding and syntax/operation table for a system call interrupt (SYSCALL) instruction in accordance with the present invention; 
         FIG. 2B  illustrates a four mode interrupt transition state diagram; 
         FIG. 3  illustrates external and internal interrupt requests to and output from a system interrupt select unit in accordance with the present invention; 
         FIG. 4  illustrates how a single general purpose interrupt (GPI) bit of an interrupt request register (IRR) is generated in accordance with the present invention; 
         FIG. 5  illustrates how a non maskable interrupt bit in the IRR is generated from an OR of its sources; 
         FIG. 6  illustrates how a debug interrupt bit in the IRR is generated from an OR of its sources; 
         FIG. 7  illustrates an exemplary interrupt vector table (IVT) which may suitably reside in instruction memory; 
         FIG. 8  illustrates a SYSCALL instruction vector mapping in accordance with the present invention; 
         FIG. 9  illustrates the registers involved in interrupt processing; 
         FIG. 10A  illustrates a sliding interrupt processing pipeline diagram; 
         FIG. 10B  illustrates interrupt forwarding registers used in the SP and all PEs; 
         FIG. 10C  illustrates pipeline flow when an interrupt occurs and the saving of flag information in saved status registers (SSRs); 
         FIG. 10D  illustrates pipeline flow for single cycle short instruction words when a user mode program is preempted by a GPI; 
         FIG. 11  illustrates a CE 3 c encoding description for 3-bit conditional execution; 
         FIG. 12  illustrates a CE 2 b encoding description for 2-bit conditional execution; 
         FIG. 13  illustrates a status and control register  0  (SCR 0 ) bit placement; 
         FIG. 14A  illustrates a SetCC register 5-bit encoding description for conditional execution and PE exception interrupts; 
         FIG. 14B  illustrates a SetCC register 5-bit encoding description for conditional execution and PE exception interrupts; 
         FIG. 15  illustrates an alternative implementation for a PE exception interface to the SP; 
         FIG. 16  illustrates an alternative implementation for PE address generation for a PE exception interface to the SP; 
         FIG. 17  illustrates aspects of an interrupt vector table for use in conjunction with the present invention; 
         FIG. 18  illustrates aspects of the utilization of a debug instruction register (DBIR); 
         FIG. 19  illustrates aspects of the utilization of DSP control register (DSPCTL); 
         FIG. 20  illustrates aspects of the utilization of a debug status register (DBSTAT); 
         FIGS. 21 and 22  illustrate aspects of the utilization of a debug-data-out (DBDOUT) and debug-data-in (DBDIN) register, respectively; and 
         FIG. 23  illustrates aspects of an exemplary DSP ManArray residing on an MCB and ManArray data bus (MDB). 
     
    
    
     DETAILED DESCRIPTION 
     Further details of a presently preferred ManArray core, architecture, and instructions for use in conjunction with the present invention are found in U.S. Pat. No. 6,023,753, U.S. Pat. No. 6,167,502, U.S. Pat. No. 6,343,356, U.S. Pat. No. 6,167,501, U.S. Pat. No. 6,219,776, U.S. Pat. No. 6,151,668, U.S. Pat. No. 6,173,389, U.S. Pat. No. 6,216,223, U.S. Pat. No. 6,366,999, U.S. Pat. No. 6,446,190, U.S. Pat. No. 6,356,994, U.S. Pat. No. 6,408,382, U.S. Pat. No. 6,697,427, U.S. Pat. No. 6,260,082, U.S. Pat. No. 6,256,683, U.S. Pat. No. 6,397,324, U.S. patent application Ser. No. 09/598,567 entitled “Methods and Apparatus for Improved Efficiency in Pipeline Simulation and Emulation” filed Jun. 21, 2000, U.S. Pat. No. 6,622,234, U.S. Pat. No. 6,735,690, U.S. Pat. No. 6,654,870, U.S. patent application Ser. No. 09/599,980 entitled “Methods and Apparatus for Parallel Processing Utilizing a Manifold Array (ManArray) Architecture and Instruction Syntax” filed Jun. 22, 2000, U.S. patent application Ser. No. 09/791,940 entitled “Methods and Apparatus for Providing Bit-Reversal and Multicast Functions Utilizing DMA Controller” filed Feb. 23, 2001, and U.S. patent application Ser. No. 09/792,819 entitled “Methods and Apparatus for Flexible Strength Coprocessing Interface” filed Feb. 23, 2001, all of which are assigned to the assignee of the present invention and incorporated by reference herein in their entirety. 
     Interrupt Processing 
     Up to 32 interrupts including general purpose interrupts (GPI- 4 -GPI- 31 ), non-maskable interrupts (NMI), and others, are recognized, prioritized, and processed in this exemplary ManArray scalable array processor in accordance with the present invention as described further below. To begin with, a processor interrupt is an event which causes the preemption of the currently executing program in order to initiate special program actions. Processing an interrupt generally involves the following steps: 
     Save the minimum context of the currently executing program, 
     Save the current instruction address (or program counter), 
     Determine the interrupt service routine (ISR) start address and branch to it, 
     Execute the interrupt program code until a “return from interrupt” instruction is decoded, 
     Restore the interrupted program&#39;s context, and 
     Restore the program counter and resume the interrupted program. 
     Interrupts are specified in three primary ways: a classification of the interrupt signals into three levels, whether they are asynchronous versus synchronous, and maskable versus non-maskable. Interrupt level is a classification of interrupt signals where the classification is by rank or degree of importance. In an exemplary ManArray system, there are three levels of interrupts where 1 is the lowest and 3 the highest. These ManArray interrupts levels are: interrupt level  1  is for general purpose interrupt (GPI) and system call interrupt (SYSCALL); interrupt level  2  is for NMI; and interrupt level  3  is for Debug. SYSCALL is an instruction which causes the address of an instruction immediately following SYSCALL to be saved in a general-purpose interrupt link register (GPILR) and the program counter (PC) is loaded with the specified vector from the system vector table. The system vector table contains 32 vectors numbered from 0 to 31. Each vector contains a 32-bit address used as the target of a SYSCALL.  FIG. 2A  shows an exemplary encoding  202  and a syntax/operation table  204  for a presently preferred SYSCALL instruction. 
     By design choice, interrupts at one classification level cannot preempt interrupts at the same level or interrupts at a higher level, unless this rule is specifically overridden by software, but may preempt interrupts at a lower level. This condition creates a hierarchical interrupt structure. Synchronous interrupts occur as a result of instruction execution while asynchronous interrupts occur as a result of events external to the instruction processing pipeline. Maskable interrupts are those which may be enabled or disabled by software while non-maskable interrupts may not be disabled, once they have been enabled, by software. Interrupt enable/disable bits control whether an interrupt is serviced or not. An interrupt can become pending even if it is disabled. 
     Interrupt hardware provides for the following: 
     Interrupt sources and source selection, 
     Interrupt control (enable/disable), 
     Interrupt mapping: source event-to-ISR, and 
     Hardware support for context save/restore. 
     These items are discussed further below. 
     Interrupt Modes and Priorities 
     In ManArray processors, there are four interrupt modes of operation not including low power modes, and three levels of interrupts which cause the processor to switch between modes. The modes shown in the four mode interrupt transition state diagram  200  of  FIG. 2B  are: a user mode  205 , a system mode  210 , an NMI mode  215 , and a debug mode  220 . User mode is the normal mode of operation for an application program, system mode is the mode of operation associated with handling a first level type of interrupt, such as a GPI or SYSCALL, NMI mode is the mode of operation associated with the handling of a non-maskable interrupt, for example the processing state associated with a loss of power interrupt, and debug mode is the mode of operation associated with the handling of a debut interrupt, such as single step and break points. 
     A processor mode of operation is characterized by the type of interrupts that can, by default, preempt it and the hardware support for context saving and restoration. In an exemplary ManArray core, there are up to 28 GPI level interrupts that may be pending, GPI- 04  through GPI- 31 , with GPI- 04  having highest priority and GPI- 31  lowest when more than one GPI is asserted simultaneously. State diagram  200  of  FIG. 2B  illustrates the processor modes and how interrupts of each level cause mode transitions. The interrupt hardware automatically masks interrupts (disables interrupt service) at the same or lower level once an interrupt is accepted for processing (acknowledged). The software may reenable a pending interrupt, but this should be done only after copying to memory the registers which were saved by hardware when the interrupt being processed was acknowledged, otherwise they will be overwritten. The default rules are: 
     GPI  233 , SYSCALL  234 , NMI  232  and debug interrupts  231  may preempt a user mode  205  program. SYSCALL  234  does this explicitly. 
     NMI  237  and debug interrupts  236  may preempt a GPI program (ISR) running in system mode  210 . 
     Debug interrupts  238  may preempt an NMI mode  215  program (ISR). 
     GPIs save status (PC and flags) and 2-cycle instruction data registers when acknowledged. SYSCALL  234  operates the same as a GPI  233  from the standpoint of saving state, and uses the same registers as the GPIs  233 . 
     Debug interrupts  231  save status and 2-cycle instruction data registers when they preempt user mode  205  programs, but save only status information when they preempt system mode ISRs  210  or NMI ISRs  215 . The state saved during interrupt processing is discussed further below. 
     NMI interrupts  237  save status but share the same hardware with system mode  210 . Therefore, non-maskable interrupts are not fully recoverable to the pre-interrupt state, but the context in which they occur is saved. 
     3—Interrupt Sources 
     There are multiple sources of interrupts to a DSP core, such as the ManArray processor described herein. These sources may be divided into two basic types, synchronous and asynchronous. Synchronous interrupts are generated as a direct result of instruction execution within the DSP core. Asynchronous interrupts are generated as a result of other System events. Asynchronous interrupt sources may be further divided into external sources (those coming from outside the ManArray system core) and internal sources (those coming from devices within the system core). Up to 32 interrupt signals may be simultaneously asserted to the DSP core at any time, and each of these 32 may arise from multiple sources. A module called the system interrupt select unit (SISU) gathers all interrupt sources and, based on its configuration which is programmable in software, selects which of the possible 32 interrupts may be sent to the DSP core. There is a central interrupt controller  320  shown in  FIG. 3  called the interrupt control unit (ICU) within the DSP core. One task of the ICU is to arbitrate between the 32 pending interrupts which are held in an interrupt request register (IRR) within the ICU. The ICU arbitrates between pending interrupts in the IRR on each cycle. 
     Synchronous Interrupt Sources 
     One method of initiating an interrupt is by directly setting bits in the interrupt request register (IRR) that is located in the DSP interrupt control unit (ICU)  320 . This direct setting may be done by load instructions or DSU COPY or BIT operations. 
     Another method of initiating an interrupt is by using a SYSCALL instruction. This SYSCALL initiated interrupt is a synchronous interrupt which operates at the same level as GPIs. SYSCALL is a control instruction which combines the features of a call instruction with those of an interrupt. The argument to the SYSCALL instruction is a vector number. This number refers to an entry in the SYSCALL table  800  of  FIG. 8  which is located in SP instruction memory starting at address 0x00000080 through address 0x000000FF containing 32 vectors. A SYSCALL is at the same level as a GPI and causes GPIs to be disabled via the general purpose interrupt enable (GIE) bit in status and control register  0  (SCR 0 ). It also uses the same interrupt status and link registers as a GPI. 
     Asynchronous Interrupt Sources 
     Asynchronous interrupt sources are grouped under their respective interrupt levels, Debug, NMI and GPI. The address interrupt described further below can generate any of these three levels of interrupts. 
     Debug and Address Interrupts 
     Debug interrupt resources include the debug control register, debug instruction register and debug breakpoint registers. Examples of debug interrupts in the context of the exemplary ManArray processor are for software break points and for single stepping the processor. 
     Address interrupts are a mechanism for invoking any interrupt by writing to a particular address on the MCB as listed in table  700  of FIG.  7 . When a write is detected to an address mapped to an address interrupt, the corresponding interrupt signal is asserted to the DSP core interrupt control unit. There are four ranges of 32 byte addresses each of which are defined to generate address interrupts. A write to an address in a first range (Range  0 )  720  causes the corresponding interrupt, a single pulse on the wire to the ICU. A write to a second range (Range  1 )  725  causes assertion of the corresponding interrupt signal and also writes the data to a register “mailbox” (MBOX 1 ). A write to further ranges (Ranges  2  and  3 )  730  and  735 , respectively, has the same effect as a write to Range  1 , with data going to register mailboxes  2  and  3 , respectively. In another example, an address interrupt may be used to generate an NMI to the DSP core by writing to one of the addresses associated with an NMI row  740  and one of the columns  710 . For further details, see the interrupt source/vector table of FIG.  7  and its discussion below. 
     NMI 
     The NMI may come from either an internal or external source. It may be invoked by either a signal or by an address interrupt. 
     GPI Level Interrupts 
     The general purpose interrupts may suitably include, four example, DMA, timer, bus errors, external interrupts, and address interrupts. There are four DMA interrupt signals (wires), two from each DMA lane controller (LC). LCs are also capable of generating address interrupts via the MCB. 
     A system timer is designed to provide a periodic interrupt source and an absolute time reference. 
     When a bus master generates a target address which is not acknowledged by a slave device, an interrupt may be generated. 
     External interrupts are signals which are inputs to the processor system core interface. 
     An address interrupt may be used to generate any GPI to the DSP core, in a similar manner to that described above in connection debug and address interrupts. 
     Interrupt Selection 
     External and internal interrupt signals converge at a system interrupt select unit (SISU)  310  shown in interrupt interface  300  of FIG.  3 . Registers in this unit allow selection and control of internal and external interrupt sources for sending to the DSP ICU. A single register, the interrupt source control register (INTSRC) determines if a particular interrupt vector will respond to an internal or external interrupt.  FIG. 3  shows the interrupt sources converging at the SISU  310  and the resulting set of 30 interrupt signals  330  sent to the interrupt request register (IRR) in the DSP ICU  320 . 
       FIG. 4  shows logic circuitry  400  to illustrate how a single GPI bit of the interrupt request register (IRR) is generated. A core interrupt select register (CISRS) bit  412  selects via multiplexer  410  between an external  415  or internal  420  interrupt source. An address interrupt  425  enabled by an address interrupt enable register (AIER)  435  or a selected interrupt source  430  generates the interrupt request  440 .  FIG. 5  shows logic circuitry  500  which illustrates how the NMI bit in the IRR is generated from its sources. Note that the sources are Ored ( 510 ,  520 ) together rather than multiplexed allowing any NMI event to pass through unmasked.  FIG. 6  shows logic circuitry  600  illustrating how the DBG bit in the IRR is generated from its sources. Note again that the sources are ORed ( 610 ,  620 ) together rather than multiplexed. 
     Mapping Interrupts to Interrupt Service Routines (ISRs) 
     There are two mechanisms for mapping interrupt events to their associated ISRs. Asynchronous interrupts are mapped to interrupt handlers through an interrupt vector table (IVT)  700  shown in  FIG. 7  which also describes the assignment of interrupt sources to their corresponding vectors in the interrupt vector table. 
     Software generated SYSCALL interrupts are mapped to interrupt handlers through a SYSCALL vector table  800  shown in FIG.  8 . The interrupt vector table  700  may advantageously reside in a processor instruction memory from address 0x00000000 through address 0x0000 007F. It consists of 32 addresses, each of which contains the address of the first instruction of an ISR corresponding to an interrupt source. 
     An example of operation in accordance with the present invention is discussed below. Interrupt GPI- 04   715  of  FIG. 7  has an associated interrupt vector (address pointer) 04 at address 0x00000010 in instruction memory which should be initialized to contain the address of the first instruction of an ISR for GIP- 04 . This vector may be invoked by an external interrupt source, if the external source is enabled in the INTSRC register. In the exemplary ManArray processor, when GPI- 04  is configured for an internal source, the interrupt may be asserted by the DSP system timer. In addition, MCB data writes to addresses 0x00300204, 0×00300224, 0×00300244, and 0x00300264 will cause this interrupt to be asserted if their respective ranges are enabled in the address interrupt enable register (ADIEN). Writes to the last three addresses will additionally latch data in the corresponding “mailbox” register MBOX 1 , MBOX 2 , or MBOX 3  which can be used for interprocessor communication. 
       FIG. 8  shows SYSCALL vector mapping  800 . ISRs which are invoked with SYSCALL have the same characteristics as GPI ISRs. 
     Interrupt Control 
     Registers involved with interrupt control are shown in register table  900  of FIG.  9 . 
     Further details of the presently preferred interrupt source control register and the address interrupt enable register are shown in the tables below 
     
       
         
               
               
               
               
               
               
               
               
               
               
               
               
               
               
               
               
               
             
               
               
               
               
               
               
               
               
               
               
               
               
               
               
               
               
             
           
               
                   
               
             
             
               
                 3 
                 3 
                 2 
                 2 
                 2 
                 2 
                 2 
                 2 
                 2 
                 2 
                 2 
                 2 
                 1 
                 1 
                 1 
                 1 
                 1 
               
               
                 1 
                 0 
                 9 
                 8 
                 7 
                 6 
                 5 
                 4 
                 3 
                 2 
                 1 
                 0 
                 9 
                 8 
                 7 
                 6 
                 5 
               
               
                 E 
                 E 
                 E 
                 E 
                 E 
                 E 
                 E 
                 E 
                 E 
                 E 
                 E 
                 E 
                 E 
                 E 
                 E 
                 E 
                 E 
               
               
                 X 
                 X 
                 X 
                 X 
                 X 
                 X 
                 X 
                 X 
                 X 
                 X 
                 X 
                 X 
                 X 
                 X 
                 X 
                 X 
                 X 
               
               
                 T 
                 T 
                 T 
                 T 
                 T 
                 T 
                 T 
                 T 
                 T 
                 T 
                 T 
                 T 
                 T 
                 T 
                 T 
                 T 
                 T 
               
               
                 3 
                 3 
                 2 
                 2 
                 2 
                 2 
                 2 
                 2 
                 2 
                 2 
                 2 
                 2 
                 1 
                 1 
                 1 
                 1 
                 1 
               
               
                 1 
                 0 
                 9 
                 8 
                 7 
                 6 
                 5 
                 4 
                 3 
                 2 
                 1 
                 0 
                 9 
                 8 
                 7 
                 6 
                 5 
               
               
                   
               
             
          
           
               
                   
                 1 
                 1 
                 1 
                 1 
                 1 
                 0 
                 0 
                 0 
                 0 
                 0 
                 0 
                 0 
                 0 
                 0 
                 0 
               
               
                   
                 4 
                 3 
                 2 
                 1 
                 0 
                 9 
                 8 
                 7 
                 6 
                 5 
                 4 
                 3 
                 2 
                 1 
                 0 
               
               
                   
                 E 
                 E 
                 E 
                 E 
                 E 
                 E 
                 E 
                 E 
                 E 
                 E 
                 E 
                 R 
                 R 
                 R 
                 R 
               
               
                   
                 X 
                 X 
                 X 
                 X 
                 X 
                 X 
                 X 
                 X 
                 X 
                 X 
                 X 
               
               
                   
                 T 
                 T 
                 T 
                 T 
                 T 
                 T 
                 T 
                 T 
                 T 
                 T 
                 T 
               
               
                   
                 1 
                 1 
                 1 
                 1 
                 1 
                 0 
                 0 
                 0 
                 0 
                 0 
                 0 
               
               
                   
                 4 
                 3 
                 2 
                 1 
                 0 
                 9 
                 8 
                 7 
                 6 
                 5 
                 4 
               
               
                   
                   
               
               
                   
                 INTSRC Interrupt Source Configuration Register Table  
               
               
                   
                 Reset value: 0x00000000  
               
               
                   
                 R Reserved  
               
               
                   
                 EXTxx 0 = Internal source  
               
               
                   
                 1 = External source  
               
             
          
         
       
     
                                                                                                                                                                         ADIEN Address Interrupt Enable Register       Reset value: 0x00000000                                3   3   2   2   2   2   2   2   2   2   2   2   1   1   1   1   1       1   0   9   8   7   6   5   4   3   2   1   0   9   8   7   6   5                        1   1   1   1   1   0   0   0   0   0   0   0   0   0   0               4   3   2   1   0   9   8   7   6   5   4   3   2   1   0                                                       A   A   A   A                                                       I   I   I   I                                                       R   R   R   R                                                       3   2   1   0                       AIRX Enable Address Interrupt Range ‘x’           0 = Address Interrupt for range ‘x’ disabled            1 = Address Interrupt for range ‘x’ enabled             
Address interrupts are triggered by writes to specific addresses (mapped to the ManArray Control Bus). Each range contains 32 (byte) addresses. When a range&#39;s AIR bit is set, a write to a particular address in the range causes the corresponding interrupt to be asserted to the DSP core.
 
Interrupt Processing Specifics
 
Interrupt processing involves the following steps:
 
     1. Interrupt detection, 
     2. Interrupt arbitration, 
     3. Save essential program state (PC, flags, 2-cycle target data), 
     4. Fetch IVT vector into PC, 
     5. Execute ISR, 
     6. Execute return from interrupt (RETI), 
     7. Restore essential program state, and 
     8. Restore PC from appropriate interrupt link register. 
     When multiple interrupts are pending their service order is as follows: Debug, NMI, and GPI- 04 , GPI- 05 , . . . etc. 
     A SYSCALL instruction, if in decode, will execute as if it were of higher priority than any GPI. If there is an NMI or Debug interrupt pending, then the SYSCALL ISR will be preempted after the first instruction is admitted to the pipe (only one instruction of the ISR will execute). 
     One instruction is allowed to execute at any level before the next interrupt is allowed to preempt. This constraint means that if an RETI is executed at the end of a GPI ISR and another GPI is pending, then exactly one instruction of the USER level program will execute before the next GPI&#39;s ISR is fetched. 
     The Debug interrupt saves PC, flags and interrupt forwarding registers (IFRs) when it is accepted for processing (acknowledged) while in User mode. If it is acknowledged while in GPI mode or NMI mode, it will only save PC and flags as it uses the same IFRs as the GPI level. 
     If processing a Debug interrupt ISR, and the Debug IRR bit is set, then an RETI will result in exactly one instruction executing before returning to the Debug ISR. 
     Load VLIW (LV) instructions are not interruptible and therefore are considered one (multi-cycle) instruction. Further details of LV instructions are provided in U.S. Pat. No. 6,151,668 which is incorporated by reference herein in its entirety. 
     Interrupt Pipeline Diagrams 
       FIG. 10A  depicts an interrupt pipeline diagram  1000  that can be used to depict the events that happen in an instruction flow when an interrupt occurs. To use the diagram for this purpose, follow these directions: 
     1. Cut  FIG. 10A  along dashed line  1002 , and 
     2. Slide “instruction stream” I 0 -I 7   1030  under execution units fetch (F), decode (DEC), execute  1  (Ex 1 ), condition return  1 /execute  2  (CR 1 /EX 2 ) and condition return  2  (CR 2 ) to  1032  observe flag generation and condition feedback visually.  FIG. 10B  illustrates a system  1050  with interrupt forwarding registers used in an SP and all PEs with functional units, load unit (LU)  1052 , store unit (SU)  1054 , DSU  1056 , ALU  1058 , MAU  1060  and condition generation unit (CGU)  1062 . Configurable register file, also known as compute register file (CRF)  1064  is also shown.  FIG. 10C  shows a flag table  1080  illustrating saved flag information within the saved status registers (SSRs). 
       FIG. 10A  is based upon the following assumptions: 
     1. Only current flags  1026  and hot conditions  1034  from condition return  1  (CR 1 )  1004  and hot conditions  1036  from CR 2   1006  affect conditional execution. Hot conditions are the condition information generated in the last stage of an execution unit&#39;s operation and are available in the condition return stage of the pipeline prior to their being latched at the end of the condition return stage. The net result of condition generation unit (CGU)  1062  condition reduction is labeled “Condex flags” ( 1038 ). 
     2. Execution unit updates (EX Flag Updates)  1040  do not affect conditional execution until the instruction which generates them reaches CR 1  phase. 
     3. Interrupt acknowledge occurs between I 3   1008  and I 4   1010 . On RETI, the state of the pipe must be restored so that it appears to I 4  as if no interrupt had occurred. 
     4. Each execution unit supplies hot condition flags and pipe phase information. The CGU  1062  must decode this information into a set of flags from each phase or “no flags” if a phase does not have an instruction which updates flags. Using this information, it can supply the correct “Condex flags”  1038  to the DEC and EX 1  in stages  1012  and  1014 , and update the latched flags  1042  correctly. 
     5. Note that the muxes  1016 ,  1018  and  1020  represent the logical “selection” between flag information from each phase. 
     Referring to FIG.  10 A and sliding the instructions I 0 -I 7   1030  right along the execution units  1032 , interrupt processing proceeds as follows: 
     1. When instruction  3  (I 3 )  1008  is in DEC  1012 : The interrupt is acknowledged. The fetch program counter (PC) which contains the address of I 4   1010  is saved to the correct interrupt link register (ILR). 
     2. When I 3  is in execute  1  (EX 1 ) pipeline stage  1014 : Update all flags according to I 1   1022 , I 2   1023  and I 3   1008  normally. Save the Condex flags. These are the “hot” flags which are to be supplied to I 4   1010  when it is in decode. 
     3. When I 3   1008  is in CR 1   1004 : Save the status and control register (SCR 0 ) since this might be read by I 4  in EX 1  and it might have been updated by I 3  in EX 1 . Update Condex flags based on I 2  and I 3 , and save the Condex flags. These will be fed back to I 4   1010  and I 5   1024  and provided as input to flag update mux  1016  (selecting between Condex flags and EX Flag Updates). If I 3  contains a 2-cycle instruction, execution unit result data must be saved to an interrupt forwarding register (IFR). Both ALU  1058  and MAU  1060  require 64-bit IFRs to save this data. 
     4. When I 3  is in CR 2 : Since I 3  might be a 2-cycle instruction, save CR 2  flags (shown in figure). These flags will be fed into the CR 1 /CR 2  flag select mux  1020  when I 4  reaches CR 1 . All other select inputs will by then be supplied by new instructions I 4  and I 5 . 
     On the return from interrupt (RETI), the following events occur: 
     1. Restore ILR to fetch PC and fetch I 4 . 
     2. I 4  in DEC: Supply Condex flags that were saved in step 2 above. These flags will be used for conditional execution. Restore saved SCR 0  (from Step 3) since this SCR 0  is read by I 4 . 
     3. I 4  in EX 1 : Supply Condex flags that were saved in Step 3 above for I 4  and I 5  conditional execution. Condex flags are also supplied to EX/Condex Flag select mux  1016 . Since I 4  provides flag information to the CGU, the CGU determines the proper update based on the saved Condex flag information and new I 4  EX flag update information. If 2-cycle data from I 3  was saved, supply this to the write-back path of CRF  1064  via multiplexers  1065  and  1066 . This will update the CRF  1064  unless I 4  contains 1-cycle instructions in the same unit(s) that I 3  used for 2-cycle instructions. 
     4. I 4  in CR 1 : Supply CR 2  flags to CR 1 /CR 2  mux  1020 , with all other mux controls provided normally by CGU based on inputs from instructions (I 4  and I 5 ) in earlier stages. 
     5. Done, instruction processing continues normally. 
     The hardware provides interrupt forwarding registers  1070 - 1076  as illustrated in the system  1050  of  FIG. 10B , in the SP and all PEs that are used as follows: 
     (1) When an interrupt occurs and is acknowledged, all instructions in the decode phase are allowed to proceed through execute. One-cycle instructions are allowed to complete and update their target registers and flags. Any two-cycle instructions are allowed to complete also, but their output, which includes result data, result operand register addresses and flag information, is saved in a set of special purpose registers termed the “interrupt forwarding registers” (IFRs)  1070 - 1076  as shown in  FIG. 10B , and no update is made to the register file (CRF)  1064  or status registers. 
     Uniquely, when an interrupt occurs, interface signals are provided to all PEs to support the following operations independently in each PE dependent upon the local PE instruction sequence prior to the interrupt. For example, there can be a different mixture of 1-cycle and 2-cycle instructions in each PE at the time of an interrupt and by using this signal interface and local information in each PE the proper operation will occur in each PE on the return from interrupt, providing synchronized interrupt control in the multiple PE environment. These interface signals include save/restore signals, interrupt type, and extended or normal pipe status. Specifically, these interface signals are: 
     Save SSR State Machine State (SP_VCU_s_ssr_state[ 1 : 0 ]) 
     These two bits indicate the state of an internal Save Saved Status Register (SSR) state machine. The signals represent 4 possible states (IDLE, I 4 _EX, I 5 _EX, I 6 _EX). When not in the idle state, the Save SSR state machine indicates the phase of the pipe that the interrupted instruction would be in had an interrupt not occurred. If you consider a sequence of 6 instructions (I 1 , I 2 , . . . , I 6 ), and the fourth instruction is interrupted, the listed state machine labels indicate when the 4 th , 5 th  and 6 th  instructions would have been in the execute phase of the pipeline. This machine state information is used locally in each PE as one of the indicators for when the IFRs need to be saved and what state needs to be saved to SSRs. 
     Restore SSR State Machine State (SP_VCU_r_ssr_state[ 1 : 10 ]) 
     These bits indicate the state of an internal Restore SSR state machine. The signals represent 4 possible states (IDLE, I 4 _DC, I 5 _DC, I 6 _DC). When not in the idle state, the Restore SSR state machine indicates the phase of the pipe that the interrupted instruction is in after it is fetched and put into the pipe again (i.e., from a return from interrupt). If you consider a sequence of 6 instructions (I 1 , I 2 , . . . , I 6 ), and the fourth instruction is interrupted, the state machine labels indicate when the 4 th , 5 th  and 6 th  instructions are in the decode phase of the pipeline. This machine state information is used locally in each PE as one of the indicators for when the IFRs need to be restored and when state needs to be restored from the SSRs. 
     Save SSRs (SP_VCU_save_ssr) 
     This bit indicates when the SSRs must be saved. 
     Transfer System SSRs to User SSRs (SP_VCU_xfer_ssr) 
     This signal indicates the System SSRs must be transferred to the User SSRs. 
     Select User SSRs (VCU_sel_gssr) 
     This signal indicates which SSRs (System or User SSRs) should be used when restoring the SSR to the hot flags and SCR 0 . It is asserted when restoring flags from the System SSRs. 
     Extend Pipe when Returning from Interrupt Service Routine 
     (SP_VCU_reti_extend_pipe) 
     When asserted, this bit indicates that a return from interrupt will need to extend the pipe. 
     (2) The address of the instruction in FETCH phase (current PC) is saved to the appropriate link register. 
     (3) The interrupt handler is invoked through the normal means such as a vector table lookup and branch to target address. 
     (4) When the RETI instruction is executed, it causes the restoration of the saved SCR 0  and link address from the appropriate link and saved-status registers. 
     (5) When the instruction at the link address reaches the EXECUTE phase, the data in the interrupt forwarding registers, for those units whose last instruction prior to interrupt handling was a two-cycle instruction, is made available to the register file  1064  and the CGU  1062  instead of the data coming from the corresponding unit. From the CGU and register file point of view, this operation has the same behavior that would have occurred if the interrupt had never happened. 
       FIGS. 10C and 10D  illustrate interrupt pipeline diagrams  1080  and  1090  for an example of interrupt processing as currently implemented. The columns SSR Save  1084 , SSR-XFER  1086 , OP in Fetch  1088 , System Mode  1090  and User Mode  1092  in  FIG. 10C  show the state of the interrupt state machine for each cycle indicated in the cycle column  1082 . Further,  FIG. 10D  shows the pipeline state of a bit within the interrupt request register (IRR)  1095 , the instruction whose address is contained in the interrupt link register (ILR)  1096 , the state of the interrupt status register (ISR)  1097 , the state of the GPIE interrupt enable bit found in SCR 0   1098 , the interrupt level (ILVL)  1099 , and the instruction being processed in the set of pipeline stages (fetch (F)  1021 , predecode (PD)  1023 , decode (D)  1025 , execute  1  (EX 1 )  1027 , and condition return (CR)  1029 ). It is assumed that the individually selectable general purpose interrupts are enabled and the interrupt vector number that is stored in SCR 1  gets updated at the same time that IMOD is updated in SCR 0 . 
     In the present exemplary processes, any time an interrupt is taken, there will be 3 cycles during which information needed to restore the pipeline is saved away in the saved status registers (SSR 0 , SSR 1 , and SSR 2 ). The information is saved when the SSR-SAVE column  1084  in table  1080  has a “1” in it. The easiest way to understand how the three 32-bit SSR registers are loaded is by breaking them down into six 16-bit fields. SSR 0  is made up of the user mode decode phase (UMDP) and user mode execute phase (UMEP) components. SSR 1  is made up of the user mode condition return phase (UMCP) and system mode condition return phase (SMCP) components. SSR 2  is made up of the system mode decode phase (SMDP) and system mode execute phase (SMEP) components. 
     SMCP—System Mode Condition Return Phase (Upper Half of SSR 1 ) 
     SMEP—System Mode Execution Phase (Upper Half of SSR 2 ) 
     SMDP—System Mode Decode Phase (Lower Half of SSR 2 ) 
     UMCP—User Mode Condition Return Phase (Lower Half of SSR 1 ) 
     UMEP—User Mode Execute Phase (Upper Half of SSR 0 ) 
     UMDP—User Mode Decode Phase (Lower Half of SSR 0 ) 
     When interrupt processing begins, the data is first stored to the system mode registers. Then, depending on the mode of operation before and after the interrupt, the system mode registers, may be transferred to the user mode registers. For example, if the mode of operation before the interrupt is taken is a USER mode, the SSR-XFER will be asserted. If the SSR-XFER bit in column  1086  is asserted, the contents of the system mode registers are transferred to the user mode registers. 
     In the example shown in  FIG. 10C , the floating point subtract (Fsub), a 2-cycle instruction, is preempted by an interrupt. The Hot State Flags (HOTSFs) are control bits indicating local machine state in the exemplary implementation and these are as follows: 
     HOTSFs={HOTSF 3 , HOTSF 2 , HOTSF 1 , HOTSF 0 }; 
     HOTSF 3 =bit indicating that a 2-cycle operation is in execute and it could have control of the flag update. 
     HOTSF 2 =bit indicating that a 2-cycle ALU instruction is in the execute (EX 1 ) pipeline stage. 
     HOTSF 1 =bit indicating that a 2-cycle MAU instruction is in the execute (EX 1 ) pipeline stage. 
     HOTSF 0 =bit indicating that a LU or DSU instruction that is targeted at SCR 0  is in the execute (EX 1 ) pipeline stage. 
     In cycle  4 ,  1081 , since the SSR-SAVE signal was asserted, the FSub hotflags and hot state flags will be saved into SMCP. The SMCP is loaded with the Hotflags, arithmetic scalar flags (CNVZ) arithmetic condition flags (F 0 -F 7 ), and the HOTSFs signals for the instruction that would be in Execute if the interrupt had not occurred, in this example, the FSub. In cycle  5   1083 , SMEP is loaded with the contents of SMCP, and SMCP is loaded with the current hotflags and the hot state flags from cycle  4 . The SMCP is loaded with the Hotflags (CNVZ &amp; F 0 -F 7 ) and the HOTSFs from the previous cycle. In cycle  6   1085 , SMDP gets the contents of SMEP, SMEP gets the contents of SMCP, and SMCP gets loaded with the current hotflags, and the hot state flags for cycle  4 . The SMCP is loaded with the Hotflags (CNVZ &amp; F 0 -F 7 ) and the HOTSFs from two cycles before. 
     In cycle  7   1087 , since the SSR-XFER signal was asserted in the previous cycle, the user mode phase components are loaded with copies of the system mode phase components. 
     Whenever the SSR-save bit is asserted and a 2-cycle operation (ALU or MAU) is in the EX 2  pipeline stage, the target compute register of the 2-cycle operation is not updated. Rather, the data, address, and write enables, i.e., bits indicating data type are stored in the corresponding execution unit forwarding registers. 
     In more detail, the pipeline diagram of  FIG. 10D  depicts the events that occur when a GPI preempts a user mode program after the fetch of a single cycle subtract (Sub) short instruction word with a nonexpanded normal pipe. Note that the SSR-XFER bit  1094  is asserted in this case since it is a GPI taking the mode of operation from a user mode (ILVI=USR) to a system mode (ILVL=GPI). It would also be asserted when taking an interrupt that leaves the mode of operation in the same mode as it was before the interrupt came along (i.e., nesting general purpose interrupts). For the interrupt request register (IRR)  1095 , the bit corresponding to the interrupt taken is cleared in the IRR. The general purpose or debug interrupt link register (ILR)  1096 , holds the address of the instruction that will be executed following the interrupt. In  FIG. 10D , only one of these registers (GPILR) is shown in column  1096 . The general purpose or debug interrupt status register (GPISR or DBISR)  1097  contains a copy of SCR 0 , so that flag state may be restored following the interrupt. Here, only one of these registers (GPIhSR) is shown in column  1097 . Interrupt enable (IE), bits  31 - 29  of SCR 0  are GPI enable, NMI enable, and DBI enable—here only the applicable enable bit (GPIE)  1098  is shown. Bits  28  and  27  of SCR 0  contain the interrupt mode (IMode) which encodes the four, user, GPI, NMI, or debug modes. 
     CE 3 c Extension 
     In the exemplary ManArray processor, a hierarchical conditional execution architecture is defined comprising 1-bit, 2-bit, and 3-bit forms. The 1-bit form is a subset of the 2-bit and 3-bit forms and the 2-bit form is a subset of the 3-bit form. In the exemplary ManArray processor, the load and store units use a CE 1  1-bit form, the MAU, ALU, and DSU use the 3-bit CE 3  form, though different implementations may use subsets of the 3-bit form depending upon algorithmic needs. The hierarchical conditional execution architecture is further explained in U.S. patent application Ser. No. 09/238,446 entitled “Methods and Apparatus to Support Conditional Execution in a VLIW-Based Array Processor With Subword Execution” filed on Jan. 28, 1999 and incorporated herein in its entirety. 
     Two 3-bit forms of conditional execution, CE 3 a and CE 3 b, specify how to set the arithmetic condition flats (ACFs) using C, N, V, or Z flags. These forms are described in greater detail in the above mentioned application. A new 3-bit form is specified in the present invention and labeled CE 3 c. The N and Z options available in the 3-bit CE 3 a definition are incorporated in the new CE 3 c encoding format  1100  encodings  1105  and  1106  respectively, illustrated in FIG.  11 . The present invention addresses the adaptation of CE 2  to use its presently reserved encoding for a registered SetCC form of conditional execution. The new form of CE 2 , which is a superset of the previous CE 2 , is referred to as CE 2 b whose encoding format is shown in table  1200  of FIG.  12 . A new programmable register is used in conjunction with the CE 2 b and CE 3 c encodings and is named the SetCC field of SCR 0  as addressed further below. These bits are used to specify many new combinations of the arithmetic side effect (C, N, V, and Z) flags to cover exceptions detected in the execution units and to provide enhanced flexibility in each of the instructions for algorithmic use. Due to the improved flexibility, it may be possible to replace the original 3-bit CE 3 a or CE 3 b with CE 3 c in future architectures. Alternatively, a mode bit or bits of control could be provided and the hardware could then support the multiple forms of CE 3 . These CE 3  encodings specify whether an instruction is to unconditionally execute and not affect the ACFs, conditionally execute on true or false and not affect the ACFs, or provide a register specified conditional execution function. The arithmetic scalar flags (ASFs) are set as defined by the instruction. In an exemplary implementation for a ManArray processor, the SetCC field of 5-bits  1310  which will preferably be located in an SCR 0  register  1300  as shown in FIG.  13 . The new format of SCR 0  includes the addition of the SetCC bits  12 - 8   1310 , an exception mask bit- 13   1315 , and the maskable PE exception interrupt signal bit  20   1320 . C, N, V, Z, cc, SetCC, ccmask, and F 7 -F 0  bits are always set to 0 by reset. The proposed SetCC definition shown in encoding table  1400  of  FIGS. 14A and 14B , specifies some logical combination of flags such as packed data ORing of flags. The encoding also reserves room for floating point exception flags, or the like, for future architectures. 
     A proposed syntax defining the SetCC operations is “OptypeCC” where the CC represents the options given in  FIGS. 14A and 14B  for a number of logical combinations of the ASFs. The number of ACFs affected is determined by the packed data element count in the current instruction and shown in  FIGS. 14A and 14B .  FIGS. 14A and 14B  specify the use of packed data side effect signals C, N, V, and Z for each elemental operation of a multiple element packed data operation. These packed data side-effect signals are not programmer visible in the exemplary ManArray system. Specifically, the C 7 -C 0 , N 7 -N 0 , V 7 -V 0 , and Z 7 -Z 0  terms represent internal flag signals pertinent for each data element operation in a packed data operation. “Size” is a packed data function that selects the appropriate affected C 7 -C 0 , N 7 -N 0 , V 7 -V 0 , and Z 7 -Z 0  terms to be ORed based on the number of data elements involved in the packed data operation. For example, in a quad operation, the internal signals C 3 -C 0 , N 3 -N 0 , V 3 -V 0 , and Z 3 -Z 0  may be affected by the operation and would be involved in the ORing while C 7 -C 4 , N 7 -N 4 , V 7 -V 4 , and Z 7 -Z 4  are not affected and would not be involved in the specified operation. 
     A new form of CE 3  conditional execution architecture is next addressed with reference to FIG.  11 . Two of the CE 3 c encodings  1103  and  1104  specify the partial execution of packed data operations based upon the ACFs. CE 3 c also includes the CE 2 b general extension that controls the setting of the ACFs based upon the registered SetCC parameter  1102 . The proposed CE 3 c 3-bit conditional execution architecture in ManArray provides the programmer with five different levels of functionality: 
     1. unconditional execution of the operation, does not affect the ACFs, 
     2. conditional execution of the operation on all packed data elements, does not affect the ACFs, 
     3. unconditional execution of the operation, ACFs set as specified by the SetCC register, 
     4. conditional selection of data elements for execution, does not affect the ACFs, and 
     5. unconditional execution of the operation with control over ACF setting. 
     In each case, data elements will be affected by the operation in different ways: 
     1. In the first case, the operation always occurs on all data elements. 
     2. In the second case, the operation either occurs on all data elements or the operation does not occur at all. 
     3. In the third case, the operation always occurs on all data elements and the ACFs are set in the CR phase of this operation. The 011 CE 3 c encoding  1102  shown in  FIG. 11  would allow the ACFs F 7 -F 0  to be set as specified by a SetCC register as seen in  FIGS. 14A and 14B . 
     4. In the fourth case, the operation always occurs but only acts on those data elements that have a corresponding ACF of the appropriate value for the specified true or false coding. In this fourth case, the packed data instruction is considered to partially execute in that the update of the destination register in the SP or in parallel in the PEs only occurs where the corresponding ACF is of the designated condition. 
     5. In the fifth case, the N and Z flags represent two side effects from the instruction that is executing. An instruction may be unconditionally executed and affect the flags based on one of the conditions, N or Z. 
     The syntax defining the fourth case operations is “Tm” and “Fm,” for “true multiple” and “false multiple.” The “multiple” case uses the packed data element count in the current instruction to determine the number of flags to be considered in the operation. For example, an instruction Tm.add.sa.4h would execute the add instruction on each of the 4 halfwords based on the current settings of F 0 , F 1 , F 2 , and F 3 . This execution occurs regardless of how these four flags were set. This approach enables the testing of one data type with the operation on a second data type. For example, one could operate on quad bytes setting flags F 3 -F 0 , then a conditional quad half-word operation can be specified based on F 3 -F 0  providing partial execution of the packed data type based on the states of F 3 -F 0 . Certain instructions, primarily those in the MAU and ALU, allow a conditional execution CE 3 c 3-bit extension field to be specified. 
     PE Exception Interrupts 
     Since the interrupt logic is in an SP, such as the SP 101, a mechanism to detect exceptions and forward the PE exception information to the SP is presented next. In addition, a method of determining which instruction caused the exception interrupt, in which PE, and in which sub data type operation is also discussed. 
     One of the first questions to consider is when can an exception be detected and how will this detection be handled in the pipeline. The present invention operates utilizing a PE exception which can cause an interrupt to the SP and the PE exception is based upon conditions latched at the end of the CR phase. A whole cycle is allowed to propagate any exception signal from the PEs to the interrupt logic in the SP. Each PE is provided with an individual wire for the exception signal to be sent back to the SP where it is stored in an miscellaneous resister file (MRF) register. These PE exception signals are also ORed together to generate a maskable PE exception interrupt. The cc flag represents the maskable PE exception interrupt signal. By reading the PE exception field in an MRF register, the SP can determine which PE or PEs have exceptions. Additional details relating to the PE exception are obtained by having the SP poll the PE causing an exception to find out the other information concerning the exception such as which data element in a packed operation caused the problem. This PE-local information is stored in a PE MRF register. One acceptable approach to resetting stored exception information is to reset it automatically whenever the values are read. 
     In certain implementations, it is possible to make selectable the use of the SetCC register to either set the ACFs, cause an exception interrupt, or both for the programmed SetCC register specified condition. If the SetCC is enabled for exception interrupts and if the specified condition is detected, then an exception interrupt would be generated from the PE or PEs detecting the condition. This exception interrupt signal is maskable. If SetCC is to be used for setting ACFs and generating exception interrupts, then, depending upon system requirements, two separate SetCC type registers can be defined in a more optimum manner for each intended use. When a single SetCC register is used for both ACF and exception interrupt, note that the exception cc is tested for every cycle while the F 0  flag can only be set when an instruction is issued using  011  CE 3 c encoding  1102  as shown in FIG.  11 . 
     For determining which instruction caused an exception interrupt, a history buffer in the SP is used containing a set number of instructions in the pipeline history so that the instruction that indirectly caused the PE exception can be determined. The number of history registers used depends upon the length of the instruction pipeline. A method of tagging the instructions in the history buffer to identify which one caused the exception interrupt is used. Even in SMIMD operation, this approach is sufficient since the contents of the VIM can be accessed if necessary. An ACF history buffer in each PE and the SP can also be used to determine which packed data element caused the exception. 
     Alternatives for the Arithmetic Scalar Flag (ASF) Definition 
     The definition of the C, N, V, Z flags, known collectively as the ASFs to be used in an exemplary system specifies the ASFs to be based on the least significant operation of a packed data operation. For single or one word (1W) operations, the least significant operation is the same as the single word operation. Consequently, the JMPcc instruction based on C, N, V, Z flags set by the 1W operation is used regularly. Setting of the C, N, V, Z flags by any other type of packed data operation in preparation for a JMPcc conditional branch is not always very useful so improving the definition of the ASFs would be beneficial. 
     Improvements to the ASF definition addressed by the present invention are described below. The present C flag is replaced with a new version C′ that is an OR of the packed data C flags. Likewise the N flag is replaced with a new version N′ that is an OR of the packed data N flags, a V′ that is an OR of the packed data V flags, and a Z′ that is an OR of the packed data Z flags. The OR function is based upon the packed data size, i.e. 4H word OR four flags and an 8B word OR eight. In the 1W case, any existing code for an existing system which uses the JMPcc based upon 1W operations would also work in the new system and no change to the existing code would be needed. With the OR of the separate flags across the data types, some unique capabilities are obtained. For example, if any packed data result produced an overflow, a conditional JMP test could be easily done to branch to an error handling routine. 
     In a first option, for JMPcc conditions based upon logical combinations of C′, N′, V, and Z′, the preceding operation would need to be of the 1W single word type, otherwise the tested condition may not be very meaningful. To make JMPcc type operations based upon logical combinations of the ASF′ flags more useful, a further change is required. The execution units which produce C, N, V, and Z flags must latch the individual packed data C, N, V, and Z flag information at the end of an instruction&#39;s execution cycle. In the condition return phase, these individually latched packed data C, N, V, and Z information flags are logically combined to generate individual packed data GT, LE, and the like signals. These individual packed data GT, LE, and the like, signals can then be ORed into hot flag signals for use by the JMPcc type instructions. These OR conditions are shown in  FIGS. 14A and 14B  and are the same logical combinations used in the SetCC register specified conditions. Then, a JMPGT would branch, if “any” of the packed data operations resulted in a GT comparison. For example, following a packed data SUB instruction with a JMPGT becomes feasible. Rather than saving all packed data flags in a miscellaneous register file (MRF) register only the single hot flag state “cc” being tested for is saved in SCR 0 . Once the “cc” state has been latched in SCR 0  it can be used to cause an exception interrupt as defined further in the PE exception interrupt section below, if this interrupt is not masked. 
     As an alternate second option, it is possible to define, for both Manta and ManArray approaches that only the 1W case is meaningful for use with the JMPcc, CALLcc, and other conditional branch type instructions. By using the SetCC register and conditional execution with CE 3 b and CE 3 c, it will be possible to set the ACFs based upon a logical combination of the packed data ASFs and then use true (T.) or false (F.) forms of the JMP, CALL, and other conditional instructions to accomplish the same task. 
     For ManArray, the generic ASF is as follows: 
     Arithmetic Scalar Flags Affected 
     C=1 if a carry occurs on any packed data operation, 0 otherwise, 
     N=MSB of result of any packed data operation, 
     V=1 if an overflow occurs on any packed data operation, 0 otherwise, and 
     Z=1 if result is zero on any packed data operation, 0 otherwise. 
     PE Exception Interrupts Alternative 
     Rather than have each PE supply a separate exception wire, an alternative approach is to use a single wire that is daisy-chain ORed as the signal propagates from PE to PE, as shown for PE 0 -PEn for system  1560  of FIG.  15 . In  FIG. 15 , a single line ORed exception signal and an exemplary signal flow are illustrated where the exception cc is generated in each PE assuming that cc=0 for no exception and cc=1 for an exception. The exception cc is generated every instruction execution cycle as specified by the SetCC register. If multiple PEs cause exceptions at the same time, each exception is handled sequentially until all are handled. 
     The PE addresses are handled in a similar manner as the single exception signal. An additional set of “n” wires for a 2 n  array supplies the PE address. For example, a 4×4 array would require only five signal lines, four for the address and one for the exception signal. An exemplary functional view of suitable address logic  1600  for each PE in a 2×2 array is shown in FIG.  16 . The logic  1600  is implemented using a 2×2 AND-OR, such as AND-ORs  1602  and  1604  per PE address bit. 
     With this approach, the PE closest to the SP on the chain will block PE exception addresses behind it until the local PE&#39;s exception is cleared. It is noted that if each PE can generate multiple exception types and there becomes associated with each type a priority or level of importance, then additional interface signals can be provided between PEs to notify the adjacent PEs that a higher priority exception situation is coming from a PE higher up in the chain. This notification can cause a PE to pass the higher priority signals. In a similar manner, an exception interface can be provided that gives the exception type information along with the PE address and single exception signal. The exception types can be monitored to determine priority levels and whether a PE is to pass a signal to the next PE or not. 
     Debug Interrupt Processing 
     There is a region of DSP instruction memory called an “interrupt vector table” (IVT)  1701  and shown in  FIG. 17  which contains a sequence of instruction addresses. For the exemplary system this table resides at instruction memory address 0x0000 through 0x007F, where each entry is itself the 32-bit (4 byte) address of the first instruction to be fetched after the interrupt control unit accepts an interrupt signal corresponding to the entry. The first entry at instruction memory address 0x0000 ( 1740 ) contains the address of the first instruction to fetch after RESET is removed. The third entry at instruction memory address 0x0008 ( 1722 ) contains the address of the first instruction to be fetched when a debug interrupt occurs. Debug interrupts have the highest interrupt priority and are accepted at almost any time and cannot be masked. There are a few times at which a debug interrupt is not immediately acknowledged, such as when a load-VLIW (LV) instruction sequence is in progress, but there are few of these cases. There is a special table entry at instruction memory address 0x0004 ( 1720 ) in the exemplary system. 
     This entry has a “shadow” register  1800  associated with it called the Debug Instruction Register (DBIR) shown in FIG.  18 . In addition, there are a set of control bits that are used to determine its behavior. Normally, in responding to an interrupt, a value is fetched from the IVT and placed into the program counter (PC)  1760 , and it determines where the next instruction will be fetched. If a program branch targets an address in the IVT memory range, then the value fetched would be assumed to be an instruction and placed into the instruction decode register (IDR)  1750 . Since the IVT contains addresses and not instructions, this would normally fail. However, in the case of address 0x0004, an instruction fetch targeting this address will cause the processor to attempt to fetch from its “shadow” register, the DBIR (if it is enabled). If there is an instruction in the DBIR, then it is read and placed into the IDR for subsequent decode. If there is not an instruction in the DBIR, the processor stalls immediately, does not advance the instructions in the pipeline, and waits for an instruction to be written to the DBIR. There are three control bits which relate to the DBIR. The debug instruction register enable (DBIREN) bit  1920  of the DSP control register (DSPCTL)  1900  shown in  FIG. 19  when set to 1 enables the DBIR “shadow” register. If this bit is 0, then a fetch from 0x0004 will return the data from that instruction memory location with no special side-effects. Two other bits residing in the Debug Status Register (DBSTAT)  2000  of  FIG. 20  are the “debug instruction present” (DBIP) bit  2030 , and the “debug stall” (DBSTALL) bit  2020 . The DBIP bit is set whenever a value is written to the DBIR either from the MCB or from the SPR bus. This bit is cleared whenever an instruction fetch from 0x0004 occurs (not an interrupt vector fetch). When this bit is cleared and an instruction fetch is attempted from 0x0004 then the DBSTALL bit of the DBSTAT register is set and the processor stalls as described above. When this bit is set and an instruction fetch is attempted, the contents of the DBIR are sent to the IDR for decoding and subsequent execution. 
     When the debug interrupt vector at instruction memory address 0x0008 is loaded with a value of 0x0004, and the DBIREN bit of the DSPCTL register is set to 1 (enabling the DBIR), then when a debug interrupt occurs, 0x0004 is first loaded into the PC (vector load) and the next instruction fetch is attempted at address 0x0004. When this occurs, the processor either stalls (if DBIP=0) or fetches the instruction in the DBIR and executes it. Using this mechanism it is possible to stop the processor pipeline (having saved vital hardware state when the interrupt is accepted) and have an external agent, a test module (or debugger function), take over control of the processor. 
     As an additional note, on returning from any interrupt, at least one instruction is executed before the next interrupt vector is fetched, even if an interrupt is pending when the return-from-interrupt instruction (RETI) is executed. In the case where a debug interrupt is pending when the RETI instruction is executed, exactly one instruction is executed before fetching from the first address of the debug service routine (or from the DBIR if the vector is programmed to 0x0004). This behavior allows the program to be single-stepped by setting the debug interrupt request bit in the interrupt request register (IRR) while still in the debug interrupt handler. Then when the RETI is executed, a single instruction is executed before reentering the debug interrupt mode. 
     Two additional registers along with two control bits are used during debug processing to allow a debug host or test module to communicate with debug code running in the target processor. The debug-data-out (DBDOUT) register  2100  of FIG.  21  and the debug-data-in (DBDIN) register  2200  of  FIG. 22  are used for sending data out from the processor and reading data into the processor respectively. A write to the DBDOUT register causes a status bit, debug data output buffer full bit (DBDOBF)  2040  of the DBSTAT register to be set. This bit also controls a signal which may be routed to an interrupt on an external device (e.g. the test module or debug host). The complement of this signal is routed also to an interrupt on the target processor so that it may use interrupt notification when data has been read from the DBDOUT register. The DBDOUT register is visible to MCB bus masters and when read, the DBDOBF bit to be cleared. An alternate read address is provided which allows the DBDOUT data to be read without clearing the DBDOBF bit. When an external debug host or test module writes to the DBDIN register, the debug data input-buffer-full bit (DBDIBF)  2050  of the DBSTAT register is set. This bit also controls a signal which is routed to an interrupt on the processor target. The complement of this signal is available to be routed back to the debug host or test module as an optional interrupt source. When the target processor reads the DBDIN register, the DBDIBF bit is cleared. 
     Given the preceeding background, the following discussion describes a typical debug sequence assuming that the debug interrupt vector in the IVT is programmed with a 0x0004 (that is, pointing to the DBIR register) and the DBIR is enabled (DBIREN=1).  FIG. 23  illustrates an exemplary DSP ManArray processor  2310  residing on an MCB  2030  and an MDB  234 . An external device which we will call the “test module” residing on the MCB, initiates a debug interrupt on the target processor core. The test module is assumed be an MCB bus master supporting simple read and write accesses to slave devices on the bus. The test module actually provides an interface between some standard debug hardware (such as a JTAG port or serial port) and the MCB, and translates read/write requests into the MCB protocol. A debug interrupt may be initiated by writing to a particular MCB address, or configuring an instruction event point register described in further detail in U.S. application Ser. No. 09/598,566 to cause a debug interrupt when a particular DSP condition occurs such as fetching an instruction from a specified address, or fetching data from a particular address with a particular value. 
     The processor hardware responds to the interrupt by saving critical processor state, such as the program status and control register, SCR 0 , and several other internal bits of state. The debug interrupt vector is fetched (having contents 0x0004) into the PC and then the processor attempts to read an instruction from 0x0004 causing an access to the DBIR register. If the DBIP bit of the DBSTAT register is 0, then the processor stalls waiting for an action from the test module. When the processor stalls, the DBSTALL bit of the DBSTAT register is set to 1. This bit is also connected to a signal which may be routed (as an interrupt for example) to the test module. This is useful if an event point register is used to initiate the debug interrupt. Rather than polling the DBSTAT register, the test module may be configured to wait for the DBSTALL signal to be asserted. If the DBIP bit is set to 1, then the processor fetches the value in the DBIR and attempts to execute it as an instruction. Typically, the DBIR does not have an instruction present when the debug interrupt is asserted, allowing the processor to be stopped. 
     The debugger then reads a segment of the DSP instruction memory via the test module, and saves it in an external storage area. It replaces this segment of user program with a debug monitor program. 
     The test module then writes a jump-direct (JMPD) instruction to the DBIR. When this occurs the DBIP bit is set, and the processor fetches this instruction into the IDR for decode, after which it is cleared again. The debugger design must make sure that no programmer visible processor state is changed until it has been saved through the test module. This JMPD instruction targets the debug monitor code. 
     The monitor code is executed in such a way as to retain the program state. The DBDOUT register is used to write data values and processor state out to the test module 
     To resume program execution, the test module writes state information back to the processor using the DBDIN register. When all state has been reloaded, the debug monitor code jumps to instruction address 0x0004 which results in a debug stall. 
     The test module lastly writes an RETI instruction to the DBIR which causes the internal hardware state to be restored and execution resumed in the program where it was interrupted. 
     It will be noted that the debug sequence mentioned above could take place in several stages with successive reloads of instructions, using very little instruction memory. 
     It should also be noted that it is possible to execute the state save/restore sequence by just feeding instructions through the DBIR. Doing this requires that the PC be “locked”, that is, prevented from updating by incrementing. This is done using a bit of the DSP control register (DSPCTL) called the “lock PC” (LOCKPC) bit  1930 . When this bit is 1, the PC does is not updated as a result of instruction fetch or execution. This means when the LOCKPC bit is 1, branch instructions have no effect, other than updating the state of the user link register (ULR) (for CALL-type instructions). Typically a small amount of instruction memory is used to “inject” a debug monitor program since this allows execution of state save/restore using loop instructions providing a significant performance gain. 
     If a debug monitor is designed to be always resident in processor memory, when the debug interrupt occurs, it does not need to be directed to the DBIR, but rather to the entry point of the debug monitor code. 
     Reset of the processor is carried out using the RESETDSP bit  1940  of the DSPCTL register. Setting this bit to 1 puts the processor into a RESET state. Clearing this bit allows the processor to fetch the RESET vector from the IVT into the PC, the fetch the first program instruction from this location. It is possible to enter the debug state immediately from RESET if the value 0x0004 is placed in the reset vector address (0x0000) of the IVT, and the DBIREN bit of the DSPCTL register is set to 1. This results in the first instruction fetch coming from the DBIR register. If no instruction is present then the processor waits for an instruction to be loaded. 
     While the present invention is disclosed in a presently preferred context, it will be recognized that the teachings of the present invention may be variously embodied consistent with the disclosure and claims. By way of example, the present invention is disclosed in connection with specific aspects of the ManArray architecture. It will be recognized that the present teachings may be adapted to other present and future architectures to which they may be beneficial, or to the ManArray architecture as it evolves in the future.