Abstract:
A near-orthogonal dual-MAC instruction set is provided which implements virtually the entire functionality of the orthogonal instruction set of 272 commands using only 65 commands. The reduced instruction set is achieved by eliminating instructions based on symmetry with respect to the result of the commands and by imposing simple restrictions related to items such as the order of data presentation by the programmer. Specific selections of commands are also determined by the double word aligned memory architecture which is associated with the dual-MAC architecture. The reduced instruction set architecture preserves the functionality and inherent parallelism of the command set and requires fewer command bits to implement than the full orthogonal set.

Description:
CROSS REFERENCE TO RELATED APPLICATIONS  
       [0001]    This application claims priority under 35 U.S.C. §119 from U.S. Provisional Application Serial No. 60/058,157 entitled “NEAR-ORTHOGONAL DUAL-MAC INSTRUCTION SET WITH MINIMAL ENCODING BITS,” filed on Sep. 8, 1997, the contents of which is hereby incorporated by reference. 
     
    
     
       FIELD OF THE INVENTION  
         [0002]    This invention relates to the instruction set architecture of a dual multiply-accumulator (MAC) based digital signal processor.  
         BACKGROUND OF THE INVENTION  
         [0003]    A digital signal processor (DSP) is a special-purpose CPU utilized for digital processing and analysis of signals from analogue sources, such as sound. The analog signals are converted into digital data and analyzed using various algorithms, such as Fast Fourier Transforms. DSPs are designed for particularly fast performance of certain operations, such as multiplication, multiplying the accumulating, and shifting and accumulating, because the math-intensive processing applications for DSPs rely heavily on such operations. For this reason, a DSP will typically include special hardware circuits to perform multiplication, accumulation and shifting operations.  
           [0004]    One popular form of DSP architecture is known as a Multiply-Accumulate or MAC processor. The MAC processor implements an architecture that takes advantage of the fact that the most common data processing operations involve multiplying two values, then adding the resulting value to another and accumulating the result. These basic operations are efficiently carried out utilizing specially configured, high-speed multipliers and accumulators, hence the “Multiply-Accumulate” nomenclature. In order to increase the processing power of MAC processors, they have been designed to perform different processes concurrently. Towards this end, DSP architectures with plural MAC structures have been developed. For example, a dual MAC processor is capable of performing two independent MAC operations concurrently.  
           [0005]    A conventional multiply-accumulator (MAC) has a 2-input multiplier M which stores its output in a product register P. The product register is connected to one input of a two-input adder A whose output is stored in one of several accumulator registers. A second input of the adder is connected to the accumulator array to allow for a continuous series of cumulative operations. Conventional vector processors are made of several MAC processors operating in parallel. Each MAC operates on its own independent data stream and the parallel MACs are joined only by a common set of accumulators. The number of instructions available for each individual MAC is fairly limited and thus, even when several MACs are combined in a parallel vector processor, the total number of MAC commands which must be encoded is relatively small.  
           [0006]    The architecture of the newly designed dual-MAC processor shown in FIG. 1 differs from conventional parallel vector processors by the addition of the cross-connecting data lines. The dual-MAC architecture of FIG. 1 consists of two 32-bit input x and y (the 16-bit high and low data halves will be referred to as xh and yh, and xl and yl, respectively) which hold the operands to the two multipliers M0 and M1. The x and y registers are cross-connected to both of the multipliers so that each multiplier can operate on any two of the four possible input factors. The products p0 and p1 are accumulated with the contents of any of the accumulators a0 to a7 by the two adders A0 and A1. The p0 product is also cross-connected to the A1 adder, which is capable of 3-input addition. In the preferred embodiment, the dual-MAC processor is implemented in conjunction with an aligned double word memory architecture which can return two double words in a single 32-bit fetch.  
           [0007]    This cross-connected dual-MAC architecture allows a single FIR or IIR digital filter applied to a single data stream to be processed by both MACs in parallel, two taps at a time, where each “tap” is a multiply-accumulate operation. Conventional vector processors with no interconnects can compute two FIR filters in parallel, but each filter is processed one tap at a time. Thus, for a single FIR or IIR filter, the cross-connected architecture operates twice as quickly as a conventional vector processor.  
           [0008]    [0008]FIG. 2 is a list of all the possible instruction commands for the cross-connected dual-MAC architecture of FIG. 1. The commands are divided into accumulate statements and product statements. Each statement represents either a single operation done on one MAC side or the other, or two operations done on both sides in parallel. When these commands are implemented as part of architected instructions, each will either be an accumulate statement (add), a product statement (multiply), or a combination of addition and multiplication.  
           [0009]    As shown in FIG. 2, there are 12 possible accumulate combinations and 20 possible product combinations in the orthogonal dual-MAC instruction set. Thus, the total number of commands which can be architected in the command processor and encoded within the commands is 12*20+12+20=272. The architected cross-connections result in a combinatorial multiplication of the number of possible functions which can be encoded as architected commands.  
           [0010]    An issue which arises with this architecture is that encoding 272 separate dual-MAC operations within a command code requires 9 bits. It is advantageous to reduce the number of bits required to encode dual-MAC instructions without impacting available functionality. This is especially true when the number of bits available to encode commands is limited and other commands must also be encoded within the same limited number of bits. In the specific dual-MAC processor at issue, only 7 bits have been dedicated to encoding commands for dual-MAC operations.  
           [0011]    According to the present invention, a near-orthogonal dual-MAC instruction set is provided which implements virtually the entire functionality of the orthogonal instruction set of 272 commands using only 65 commands. The reduced instruction set is achieved by eliminating instructions based on symmetry with respect to the result of the commands and by imposing simple restrictions related to items such as the order of data presentation by the programmer. Specific selections of commands are also determined by the double word aligned memory architecture which is associated with the dual-MAC architecture. The reduced instruction set architecture preserves the functionality and inherent parallelism of the command set and requires fewer command bits to implement than the full orthogonal set.  
       
    
    
     BRIEF DESCRIPTION OF THE DRAWINGS  
       [0012]    The foregoing and other features of the present invention will be more readily apparent from the following detailed description and drawings of illustrative embodiments of the invention in which:  
         [0013]    [0013]FIG. 1 is a simplified block diagram of a dual-MAC processor.  
         [0014]    [0014]FIG. 2 is a table showing an orthogonal command set for the dual-MAC processor of FIG. 1.  
         [0015]    [0015]FIG. 3 is a table showing a near-orthogonal command set according to the present invention for the dual-MAC processor of FIG. 1. 
     
    
     DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENT  
       [0016]    As shown in FIG. 2, there are 12 possible accumulate statements and 20 possible product statements for the dual-MAC processor shown in FIG. 1, which can be architected separately or in combination. The reduction of the orthogonal instruction set to provide a near-orthogonal reduced instruction set is discussed with respect to each function type.  
         [0017]    There are four possible single two-input accumulate statements:  
           aD=aS+p 0  
           aD=aS−p 0  
           aD=aS+p 1  
           aD=aS−p 1  
         [0018]    where aD and aS are any of the 8 accumulators for the dual-MAC processor of FIG. 1. It should be noted that, in addition to encoding the dual-MAC command itself, the identity of the D and S accumulators to which the command is directed also must be stored within the command op code. When one of these commands is executed, only one of the two MAC paths will be engaged. The other will be idle. Because the result of the accumulate statement is stored in an accumulator which is equally accessible to both MAC paths, there is no need to encode commands for both paths. By default, the p0 path is chosen. The reduced command set is therefore: aD=aS+/−p0.  
         [0019]    There are four possible 3-input accumulate statements:  
           aD=aS+p 0+ p 1  
           aD=aS+p 0− p 1  
           aD=aS−p 0+ p 1  
           aD=aS−p 0− p 1  
         [0020]    Theoretically, a reduction of these commands could be made by recognizing that p0 and p1 may be “swapped” if the programmer adjusts the order of the inputs to the multiplier accordingly. However, this strategy cannot be used to reduce both the accumulate instruction set and the product instruction set, discussed below, because the accumulate and product commands must be capable of being encoded as accumulate/product pairs. Thus, only one of the two commands in the pair can be reduced in this manner. The input-swap strategy provides the greatest reduction for the product statements, discussed below, and therefore all four of the 3-input accumulate statements are implemented.  
         [0021]    There are four possible dual two-input accumulate statements, each consisting of two two-input accumulate statements which are executed in parallel:  
                                                       aD0 = aS0 + p0   aD1 = aS1 + p1           aD0 = aS0 + p0   aD1 = aS1 − p1           aD0 = aS0 − p0   aD1 = aS1 + p1           aD0 = aS0 − p0   aD1 = aS1 − p1                      
 
         [0022]    where aD0, aD1, aS0, and aS1 each refer to one of the 8 accumulators. The number of commands in this set is not reduced for the same reasons discussed with respect to the three-input accumulate statements, above. However, a reduction in encoding bits elsewhere in the command op code may be achieved by limiting the accumulators that can be selected in the command to adjacent accumulator pairs. In the preferred embodiment, aD0 is limited to even accumulator addresses and aD1 is defined as the accumulator aD0+1. The consecutive pairs of accumulators are designated aD and aDP. Similarly, accumulator pairs aS0 and aS1 are limited to aS and aSP. This reduction provides a modified command set of:  
                                                       aD = aS + p0   aDP = aSP + p1           aD = aS + p0   aDP = aSP − p1           aD = aS − p0   aDP = aSP + p1           aD = aS − p0   aDP = aSP − p1                      
 
         [0023]    Although four commands must still be encoded, only one accumulator of the pair needs to be specified since the commands are limited to adjacent accumulator pairs. Because there are eight accumulators, three bits are required to identify an accumulator. By limiting the accumulators to adjacent pairs so that only two accumulators need to be identified, as opposed to four, and selecting the even accumulator of the pair to define, the total number of bits needed to identify the accumulators in the op code is reduced from 12 to 4.  
         [0024]    There are four possible factors which can be presented to the multipliers. These factors are stored in two divided registers. The x-register holds the xh and xl factors and the y-register holds the yh and yl factors. Because of the cross-connected architecture, any two of the four factors may be input to each multiplier M0, M1.  
         [0025]    There are eight possible single-products statements:  
           p 0= xh*yh    
           p 0= xh*yl    
           p 0= xl*yh    
           p 0= xl*yl    
           p 1= xh*yh    
           p 1= xh*yl    
           p 1= xl*yh    
           p 1= xl*yl    
         [0026]    where p0 and p1 are the products output from multipliers M0 and M1 respectively. As with the single two-input accumulate statements, discussed above, only one of the two MAC paths will be engaged when one of these commands is executed. Thus, as above, the commands can be limited to only the p0 side. Further, the position of the factors within the x and y registers is under the control of the programmer. The set may be further reduced by restricting the operation to only two factor positions, arbitrarily chosen to be xh and yh. The reduced command set is therefore only the single command: p0=xh*yh.  
         [0027]    There are twelve possible dual product statements:  
                                                           1.   p0 = xh * yh   p1 = xh * yl           2.   p0 = xh * yh   p1 = xl * yh           3.   p0 = xh * yh   p1 = xl * yl           4.   p0 = xh * yl   p1 = xh * yh           5.   p0 = xh * yl   p1 = xl * yh           6.   p0 = xh * yl   p1 = xl * yl           7.   p0 = xl * yh   p1 = xh * yh           8.   p0 = xl * yh   p1 = xh * yl           9.   p0 = xl * yh   p1 = xl * yl           10.   p0 = xl * yl   p1 = xh * yh           11.   p0 = xl * yl   p1 = xh * yl           12.   p0 = xl * yl   p1 = xl * yh                      
 
         [0028]    Several of these commands result in identical multiplications being performed, differing only in which MAC processor is used and thus which product register the result appears in. The symmetric pairs are 1-4, 2-7, 3-10, 5-8, 6-11, and 9-12. Thus, a first reduction can take advantage of this symmetry and encode only one command of each symmetric pair. The reduction results in the 6 commands shown below:  
                                                           1.   p0 = xh * yh   p1 = xh * yl           2.   p0 = xh * yh   p1 = xl * yh           3.   p0 = xh * yh   p1 = xl * yl           5.   p0 = xh * yl   p1 = xl * yh           6.   p0 = xh * yl   p1 = xl * yl           9.   p0 = xl * yh   p1 = xl * yl                      
 
         [0029]    The set can be further reduced by recognizing that “nearly-symmetric” pairs can be eliminated by relying on the ability of the programmer to direct data into the x- or y-register as desired. For items 1 and 2, note that the p0 operations are identical. The p1 operations differ only in which register the high-word factor and low-word factor are chosen from. Switching the x- and y-register data in command 2 gives the same result as command 1. Thus, only one of the two commands needs to be implemented. No functionality is lost because the programmer can simply switch the order of the inputs. Items 6 and 9 are also nearly symmetric.  
         [0030]    It should be noted that in the preferred embodiment, the dual-MAC processor is implemented with an aligned double word memory architecture. As a result, this near-symmetry is not available with respect to items 3 and 5. Although in theory, the programmer has absolute control over where the factor data is stored in the registers and thus how it is presented to the dual-MAC processor, the aligned double word memory architecture of the preferred embodiment provides for two data values to be fetched in a single double word operation and stored in the x- or y-register. Switching which register the two data values are stored in does not carry with it a performance penalty. However, dividing the data requires extra commands and therefore carries a performance penalty. To avoid this situation, both commands 3 and 5 are implemented. The final reduced dual product command set is:  
                                                       p0 = xh * yh   p1 = xh * yl           p0 = xh * yh   p1 = xl * yl           p0 = xh * yl   p1 = xl * yh           p0 = xl * yh   p1 = xl * yl                      
 
         [0031]    The complete reduced command set is illustrated in FIG. 3. There are 10 different accumulate statements and 5 different product statements, resulting in a total number of architected commands equal to 10*5+10+5=65. Encoding these operations with 7 bits of the op code allows for an additional 63 commands to be implemented without increasing the number of required bits.