Abstract:
A method for scheduling computation operations on a very long instruction word processor to achieve an optimal iteration period for a cyclic algorithm uses a flow graph to aid in scheduling instructions. In the flow graph, each computation operation appears as a separate node, and the edges between nodes represent data dependencies. The flow graph is transformed into machine-readable data for use in an integer linear program. The machine-readable data expresses equations and constraints associated with the optimal iteration period of the algorithm implemented on a processor having a plurality of types of functional units. The equations and constraints comprise an objective function to be minimized, a set of operation precedent constraints, job completion constraints, iteration period constraints and functional unit constraints. The nature of the equations and constraints are modified based upon processor architecture. The minimum iteration period for completion of the computation operations, and the scheduling of nodal operations, is determined by computing an optimal solution to the integer linear program as a solution of its corresponding linear constraints. The computation operations are scheduled according to the optimal solution provided by the integer linear program.

Description:
REFERENCE TO RELATED APPLICATION  
       [0001]    The present patent application claims priority benefit of U.S. Provisional Application No. 60/240,151, filed Oct. 13, 2000, titled “COMBINED SCHEDULING AND MAPPING OF DIGITAL SIGNAL PROCESSING ALGORITHMS ON VLIW DSPS,” the content of which is hereby incorporated by reference in its entirety. 
     
    
     
       FIELD OF THE INVENTION  
         [0002]    This invention relates to the optimization of signal processing programs, and more particularly, to a process for the combined scheduling and mapping of fully deterministic digital signal processing algorithms on a processor.  
         DESCRIPTION OF THE RELATED ART  
         [0003]    Computational efficiency is critical to the effective execution of Digital Signal Processing (DSP) applications. Real-time DSP applications usually require processing large quantities of data in a short period of time. The DSP algorithms that comprise the DSP applications can be continuous and repetitive in nature, where operations are repeated in an iterative manner as samples are processed, and often possess a high degree of parallelism, where several separate operations can be executed concurrently.  
           [0004]    Because digital signal processing algorithms often possess a high degree of parallelism, multiple processors may work in parallel to perform the computations. Consequently, DSP applications are implemented on DSP hardware systems having multiple Functional Units (FUs) capable of processing data simultaneously. Such hardware systems comprise processors with FUs on a single chip architecture, referred to as Very Long Instruction Word (VLIW) architecture; where one long instruction word specifies the instructions to be performed by each of the FUs in a machine cycle. The TMS320C6xx/TMS320C64x (&#39;C6xx) family of DSPs from Texas Instruments® provides one example of a DSP processor with multiple functional units utilizing a VLIW architecture. The StarCore SC 140 by Motorola is another such example.  
           [0005]    To optimize the execution of DSP applications, the DSP algorithms should be implemented in a manner that exploits the processor architecture by utilizing instruction-level parallelism. Developing this parallelism, however, is a tedious task. Conventionally, a complier is used to detect parallel operations in a program and automatically map them onto the processor architecture. While effective in some cases, compiled code often does not utilize the full parallelism of the processor architecture.  
           [0006]    As an example, the &#39;C6xx DSP uses a RISC-like instruction set to aid the compiler with dependency checking. The compiler detects parallel operations in a program and attempts to schedule the instructions for optimal performance. In some special cases, the compiler is effective in producing parallel code. Nevertheless, code for complex algorithms, written in hand-coded assembly language, often outperforms compiler-generated code by a factor of 10-40. Writing parallel assembly language code by hand is a tedious and time consuming task, typically requiring many revisions of the code in order to detect and schedule the parallelism present in the algorithm.  
           [0007]    To improve the efficiency of mapping and scheduling, while minimizing the effort required, various techniques, particularly compiler-based solutions, have been proposed. None of these techniques, however, optimally utilize instruction-level parallelism. It is therefore needed to have an improved method and system to schedule and map the operations of a DSP algorithm onto a parallel computing system.  
         SUMMARY OF THE INVENTION  
         [0008]    The present invention addresses these and other problems by providing a method for scheduling computation operations on a very long instruction word processor so as to have a substantially optimal iteration period for a cyclic algorithm.  
           [0009]    One embodiment uses a flow graph wherein each computation operation appears as a separate node, and a plurality of edges represents data dependencies between the separate nodes. The scheduling and mapping problem is modeled on the basis of the DSP algorithm, and the processor architecture. The flow graph is transformed into machine-readable data for use in an integer linear program. The machine-readable data expresses equations and constraints associated with the optimal iteration period of the algorithm implemented on a processor having a plurality of types of functional units. The equations and constraints comprise an objective function to be minimized, a set of operation precedent constraints, job completion constraints, iteration period constraints and functional unit constraints. The nature of the equations and constraints are modified based upon processor architecture. The minimum iteration period for completion of the computation operations, and the scheduling of nodal operations, is determined by computing an optimal solution to the integer linear program as a solution of its corresponding linear constraints. The computation operations are scheduled and mapped according to the optimal solution provided by the integer linear program. 
       
    
    
     BRIEF DESCRIPTION OF THE DRAWINGS  
       [0010]    These and other features and advantages of the present invention will be appreciated, as they become better understood by reference to the following Detailed Description when considered in connection with the accompanying drawings, wherein:  
         [0011]    [0011]FIG. 1 depicts a Fully Specified Flow Graph (FSFG) of a 2 nd  order Infinite Impulse Response (IIR) filter;  
         [0012]    [0012]FIG. 2 is a block diagram of the functional units of the &#39;C6xx DSP;  
         [0013]    [0013]FIG. 3 depicts a FSFG of a 2 nd  order IIR filter with memory access; and  
         [0014]    [0014]FIG. 4 is a block diagram of the data path of a StarCore processor 
     
    
     DETAILED DESCRIPTION OF THE INVENTION  
       [0015]    The present invention is a method and system for mapping and scheduling algorithms on parallel processing units. The present invention will presently be described with reference to the aforementioned drawings. Where arrows are utilized in the drawings, it would be appreciated by one of ordinary skill in the art that the arrows represent the interconnection of elements and/or the communication of data between elements.  
         [0016]    Defining the signal processing algorithm by using a fully specified flow graph (FSFG) decreases the development time of signal processing algorithms. A FSFG is defined by the 3-tuple &lt;N,E,D&gt; where N is a set of nodes that represent the atomic operations performed on the data, E is a set of directed edges that represent the flow of data between different operations, and D is a set of ideal delays.  
         [0017]    The parameters characterizing an FSFG mapped onto multiple functional units include the following:  
         [0018]    N the set of nodes  
         [0019]    E the set of directed edges  
         [0020]    D the set of ideal delays  
         [0021]    P i/o  a set of paths from input node to output node  
         [0022]    t i  a time that node iεN completes its execution  
         [0023]    τ iteration period (time after which next iteration can be started)  
         [0024]    d i  execution time of node iεN  
         [0025]    n vw  a number of ideal delays on edge e(v, w)εE from node v to node w where (v,wεN)  
         [0026]    D i/o  a throughput delay  
         [0027]    P r  a number of processors of type r in the VLIW  
         [0028]    r a type of processor ε{adder, multiplier, register, etc.} 
         [0029]    Other variables can be optionally incorporated into a FSFG, such as cp jk , a communication path between functional units j and k, c jk , a communication cost for communication path cp jk , and u jk , a maximum number of communications on communication path cp jk  at any one instant.  
         [0030]    FSFG graphs are normally cyclic, with data dependencies between iterations. The computational latency of node i is given by d i , and t i  represents the time at which node i completes its execution. The nodes in the FSFG are atomic operations that are indivisible and depend on the computational capacity of the functional units. Atomic operations represent the smallest granularity of achievable parallelism.  
         [0031]    The FSFG of a 2 nd  order IIR filter is shown in FIG. 1. The input  150  is shown as signal x[n], and the output  151  is shown by the signal y[n]. Nodes n 1    101 , n 2    102 , n 7    107 , and n 8    108  perform addition operations, while nodes n 3    103 , n 4    104 , n 5    105 , and n 6    106  perform multiply operations.  
         [0032]    The edges of the graph represent data dependencies between the nodes. Where more than one operation depends on the output of a node, each dependency is represented as a separate edge. The separate edges are required for scheduling purposes. Node n 8    108  depends from nodes n 2    102  and n 7    107 , and the dependencies are represented by edges e 2    122  and e 11    131 , respectively. Nodes n 3    103 , n 4    104 , n 5    105 , and n 6    106  also depend from node n 2    102 , and the dependencies are represented by edges e 5    125 , e 6    126 , e 7    127 , and e 8    128 , respectively. Edges e 6    126  and e 8    128  represent dependencies from node n 2    102  but with a delay, and edges e 5    125  and e 7    127  represent dependencies from node n 2    102  with two delays. Edges e 1    121 , e 3    123 , and e 9    129  represent dependencies from nodes n 1    101 , n 3    103 , and n 5    105  to nodes n 2    102 , n 1    101 , and n 7    107  respectively. Input signals a 0 , a 1 , b 0  and b 1  [collectively not shown] represent the coefficients of the IIR filter and are inputted into n 4    104 , n 3    103 , n 6    106 , and n 5    105  respectively.  
         [0033]    The FSFG is also useful to define the parameters and constraints for a Mixed Integer Program (MIP). A mixed integer programming approach for optimally scheduling and mapping of algorithms onto a processor eases the process of hand coding. Mixed Integer Programming is similar to Linear Programming (LP), where a system is modeled using a series of linear equations. Each equation represents a constraint on the system. In addition to the constraints, there is an objective function, where the goal is to minimize (or sometimes maximize) the result.  
         [0034]    Mixed Integer Programming is useful when the feasible solutions have to be the equivalent of whole numbers or a binary decision. For example, assuming it is not feasible to schedule 1.2438 multiplication operations in a clock cycle, then the optimum number of multiplication operations must be 1 or 2. Simply rounding off values does not guarantee correct results, instead, Integer Programming must be used.  
         [0035]    The inherent constraints of the DSP and the scheduling requirements of the FSFG provide a starting point for writing an efficient signal-processing algorithm. Through trial and error, a programmer may eventually create an optimal algorithm. Through the use of Integer Linear Programming (ILP) techniques to automate this long and difficult task, a programmer can greatly reduce development time. With ILP, the incorporated variables are limited to integer values while with MIP a portion of the variables can have integer values and a portion of the variables can have real values.  
         [0036]    The scheduling of parallel instructions is driven largely by the architecture of the DSP. A simplified data path of the &#39;C6xx DSP is shown in FIG. 2. The &#39;C6xx has eight functional units divided into two groups, each group having four functional unit types, labeled .L1  210 , .S1  220 , .M1  230 , and .D1  240 , and .L2  260 , .S2  270 , .M2  280 ,. and D2  290 . Each of the four unit types can perform different specialized operations, such as, arithmetic operations, byte shift operations, multiplication or compare operations, and address generation. Each group of four functional units is also associated with a register file  200 ,  250  containing 16, 32-bit registers, each. Each functional unit reads directly from and writes directly to the register file within its own group. Additionally, the two register files are connected to the functional units of the opposite side via unidirectional cross paths  202 ,  252 . The 3 FU&#39;s on one side can access only one operand from the other side at a time. Both sides work independently. The only cross communication is via the cross paths, and these cannot be used to store a result on the register file of the other side. The &#39;C6xx also includes a control register  204  for handling memory access.  
         [0037]    The multiple functional units of the &#39;C6xx DSP are controlled by the several basic instructions found in a single long instruction word. By carefully scheduling the parallel execution of independent basic instructions, a programmer can efficiently implement signal processing algorithms.  
         [0038]    The code for a &#39;C6xx DSP must provide for the transfer of data from memory or registers between the two groups of functional units using the cross paths  202 ,  252 . The two groups of functional units are connected by their register files  200 ,  250 , so all communications between them must go through the registers. This requires modifying the FSFG to include storage of results into the registers as a node.  
         [0039]    [0039]FIG. 3 shows a new FSFG of the 2 nd  order IIR filter with memory nodes at the output of every original node. Edges e 1    321 , e 3    323 , e 7    327 , e 8    328 , e 13    333 , e 14    334 , and e 17    337  provide data for memory nodes n 9    309 , n 10    310 , n 11    311 , n 12    312 , n 13    313 , n 14    314 , and n 15    315 , respectively. Edges e 1    321 , e 3    323 , e 7    327 , e 8    328 , e 13    333 , e 14    334 , and e 17    337  represent dependencies from nodes n 1    101 , n 2    102 , n 3    103 , n 4    104 , n 5    105 , n 6    106 , and n 7    107 , respectively.  
         [0040]    Node n 8    108  depends from nodes n 10    310  and n 15    315 , and the dependencies are represented by edges e 6    326  and e 18    338 , respectively. Nodes n 3    103 , n 4    104 , n 5    105 , and n 6    106  also depend from node n 10    310 , and the dependencies are represented by edges e 9    329 , e 10    330 , e 11    331 , and e 12    332 , respectively. Edges e 10    330  and e 12    332  represent dependencies from node n 10    310  but with a delay, and edges e 9    329  and e 11    331  represent dependencies from node n 10    310  with two delays. Edges e 2    322 , e 4    324 , and e 15    335  represent dependencies from memory nodes n 9    309 , n 11    311 , and n 13    313  to nodes n 2    102 , n 1    101 , and n 7    107  respectively. Input signals a 0    160 , a 1    161 , b 0    170  and b 1    171  represent the coefficients of the IIR filter.  
         [0041]    Signal processing algorithms typically run through repeated iterations of a computation process. Because of the cyclic nature of signal processing algorithms, optimizing the iteration period results in optimization of the entire algorithm. Ideally, the iteration period takes a single cycle to complete. This is usually not possible, however, because data dependencies prevent performing all the nodes at the same time. Additionally, the number of functional units on the &#39;C6xx DSP is limited, so a single iteration period may take several VLIW cycles to complete.  
         [0042]    Minimization of the Iteration Period (τ) and the periodic throughput delay D i/o  provides the optimal schedule when given limited processing resources. The iteration period can be expressed by the equation  
         τ   j     =     {         1                      if                 j                 is                 the                 selected                 iteration                 period               0                    otherwise                                   
 
         [0043]    While it is possible to have a range of iteration periods between lower and upper bounds, only a single iteration period can be deemed valid and true, namely have the value of 1.  
         [0044]    The throughput delay D i/o  is given by the expression  
         D     t   /   o       =         ∑     p   =   1       P   r              ∑     t   =   1     T          x       (   output   )        pt           -       ∑     p   =   1       P   r              ∑     t   =   1     T          x       (   input   )        pt                                   
 
         [0045]    By weighting the iteration period by a factor of T. both the iteration period and the throughput delay can be optimized with a single equation. Using T ensures that the weighted iteration period is greater than the maximum possible throughput delay.  
         [0046]    Even though the minimum iteration period is not known in advance, the programmer can often make a reasonable estimate of the expected value. Setting a lower bound b l  and an upper bound b u  for possible iteration time periods reduces the computing time required to solve the minimization equation. The objective function is to optimize the iteration period and throughput delay by minimizing the expression  
         T          ∑     j   =     b   l         b   u            j                   τ   j           +       ∑     p   =   1       P   r              ∑     t   =   1     T          x       (   output   )        pt           -       ∑     p   =   1       P   r              ∑     t   =   1     T          x       (   input   )        pt                                 
 
         [0047]    After specifying the objective function, integer linear programming also requires defining the constraints. Inputs to some nodes depend from outputs of other nodes, so not all the nodes in the FSFG can be processed in parallel. Constraints are used to define nodes that must be processed in sequential order. Given that node v precedes node w, the time at which node w is processed must be greater than the time at which node v is processed. Further, this difference in time must be greater than the difference between the computational throughput delay and the cost of ideal delays for a given iteration period. This concept is expressed by the equation  
             t   w     -     t   v       &gt;       d   w     -       n   vw            ∑     j   =     b   l         b   u            j                   τ   j               ,       for                   e        (     v   ,   w     )         ∈   E               where                   t   i       =       ∑     t   =   1     T          t          ∑     p   =   1       P   r            x   ipt                                 
 
         [0048]    This equation does not model the costs associated with memory and registers. The functional units can communicate by using the cross paths or store data in memory, and these communication costs must be factored into the operation precedence constraints. The communication costs are given by the expression  
         ∑     t   =   1     T            ∑       p   2     =   1       P   r              x       i   2          p   2        t              ∑       p   1     =   1       P   r              c       p   2          p   1              x       i   1          p   1        t                                     
 
         [0049]    Combining these expressions, the operation precedence constraint is defined by the equation  
             ∑     t   =   1     T          t          ∑       p   2     =   1       P   r            x       i   2          p   2        t             -       ∑     t   =   1     T          t          ∑       p   1     =   1       P   r            x       i   1          p   1        t             -     d     i   2       +       n       i   1          i   2                ∑     j   =     b   l         b   u            j                   τ   j           -       ∑     t   =   1     T            ∑       p   2     =   1       P   r              x       i   2          p   2        t              ∑       p   1     =   1       P   r              c       p   2          p   1              x       i   1          p   1        t                   &gt;   0                         
 
         [0050]    The above expression is nonlinear and cannot be solved by existing MIP solvers. Therefore the Oral and Kettani transformation is applied to linearize the expression as follows:  
         Let                   y       i   2          p   2        t         =       x       i   2          p   2        t              ∑       p   1     =   1       P   r              c       p   2          p   1              x       i   1          p   1        t                     such                 that                   y       i   2          p   2        t       =     {                      0             if                   x       i   2          p   2        t         =   0                           ∑         p   1     =   1       P   r            c       p   2          p   1              x       i   1          p   1        t                 if                   x       i   2          p   2        t         =   1                                   
 
         [0051]    Replace the nonlinear y i     2     p     2     t  with a linear expression  
           ∑       p   1     =   1       P   r              c       p   2          p   1              x       i   1          p   1        t           -       b     p   2            (     1   -     x       i   2          p   2        t         )       +     z       i   2          p   2        t                 where                   b     p   2         =         ∑   p     1     P   r              c       p   2          p   1                       then                     ∑     t   =   1     T          t          ∑       p   2     =   1       P   r            x       i   2          p   2        t             -       ∑     t   =   1     T          t          ∑       p   1     =   1       P   r            x       i   1          p   1        t             -     d     i   2       +       n       i   1          i   2                ∑     j   =   lb     ub          j                   τ   j           -       ∑     t   =   1     T            ∑       p   2     =   1       P   r            {         ∑       p   1     =   1       P   r              c       p   2          p   1              x       i   1          p   1        t           +       b     p   2            (     1   +     x       i   2          p   2        t         )       +     z       i   2          p   2        t         }           &gt;   0                         
 
         [0052]    All nodes of the FSFG must be scheduled for processing a single time within each iteration period. This job completion constraint is shown by the expression  
             ∑     t   =   1     T            ∑     p   =   1       P   r            x   ipt         =   1     ,       for                 all                 nodes                 i     =   1     ,   2   ,   …              ,   N                         
 
         [0053]    Only one iteration period is selected from the range of iteration periods. This iteration period constraint is shown by the expression  
           ∑     j   =     b   l         b   u            τ   j       =   1                         
 
         [0054]    The iteration period is being minimized, so more than one time value can be assigned to the iteration period. The functional unit modulo constraint ensures that, at most, P fu  processors are used for each time classes. There are b u −b l +1 sets of iteration period. To model this, each set must be specified to constrain the problem only if its iteration period is optimal.  
         [0055]    A Functional Unit of type fu can do the operation of type fu because it represents the set of time classes for which an operation remains alive on a FU.  
           ∑     i   ∈     N   r                ∑     p   =   1       P   r              ∑     s   ∈     S   n              x   ips           &lt;       P   fu     +     M        (     1   -     τ   j       )                     for                 t     =   1     ,   2   ,   …              ,         S   n                   n     =   0     ,   1   ,   …              ,                    b   l     -     1.                   S   n         =     {       s        s                 mod                   b   l         =   n     }                   ∑     i   ∈     N   r                ∑     p   =   1       P   r              ∑     s   ∈     S   n              x   ips           &lt;       P   fu     +     M        (     1   -     τ   j       )                     for                 t     =   1     ,   2   ,   …              ,       T                 n     =   0     ,   1   ,   …              ,       b   u     -   1     ,       S   n     =     {       s        s                 mod                   b   u         =   n     }                             
 
         [0056]    M should be greater than P fu  so that an either-or-constraint condition is met.  
         [0057]    N fu =set of nodes mapped on the FU of type fu.  
         [0058]    The DSP is limited to accessing a single operand for each of the two cross paths. This load constraint is shown by the expression  
               ∑       i   2     ,       i   1     ∈   L                ∑       p   2     =   1       P   2              x       i   2          p   2        t              ∑       p   1     =   1       P   1            x       i   1          p   1        t               ≤     1                 for                 each                 time                 class                 t       =   1     ,   …              ,     T   .                           
 
         [0059]    After linearization this quadratic expression becomes  
           ∑       i   2     ,       i   1     ∈   L                ∑       p   2     =   1       P   2            {         ∑       p   1     =   1       P   1            x       i   1          p   1        t         +       b     p   2            (     1   -     x       i   2          p   2        t         )       +     z       i   2          p   1          p   2        i         }         ≤   1             where                   p   1       ,       p   2                   belong                 to                 different                 sides                           
 
         [0060]    The linearization process adds the following constraints to the MIP  
           z       i   2          p   2        t       +       ∑       p   i     =   1       P   1            x       i   1          p   1        t         -       b     p   2            (     1   -     x       i   2          p   2        t         )         ≥   0                 z       i   2          p   2        t       ≥     0                 for                 all                 store                 edges                 and                 for                 all                 t       =   1     ,   …              ,   T   ,     
            p   2     =   1     ,   …              ,       P   fu                   and                 z       i   2          p   1          p   2        t       +       ∑       p   1     =   1       P   1            x       i   1          p   1        t         -       b     p   2            (     1   -     x       1   2          p   2        t         )         ≥   0             z       i   2          p   1          p   2        t       ≥     0                 for                 all                 load                 edges                           
 
         [0061]    The performance of an operation by the FU p on a node i at time t is represented by the setting the value of x ipt  to 1. If no operation is performed with those parameters, the value is set to 0. This 0-1 constraint is shown by the expression  
         x   ipt     =     {         1                      node                 i                 is                 processed                 by                 FU                 p                 at                 time                 t               0                    otherwise                                   
 
         [0062]    i=1,2, . . . , N  
         [0063]    p=1,2, . . . , P fu    
         [0064]    t=1,2, . . . , T  
         [0065]    N=Number of operation Nodes in the FSFG  
         [0066]    P fu =Number of FUs of Type fu in the VLIW  
         [0067]    f u ε={Adder, Multiplier, Register} etc.  
         [0068]    T=Number of time classes considered.  
         [0069]    The following example shows the results for a 2 nd  order IIR filter shown in FIG. 3.  
         [0070]    N=15 as shown in FSFG of FIG. 3.  
         [0071]    P a =the Number of Adders in the &#39;C6xx  
         [0072]    P m =the Number of Multipliers in the &#39;C6xx  
         [0073]    Pr=the Number of Registers in the ° C.6xx  
         [0074]    T=8 (approximate time to serially process the 8 nodes)  
         [0075]    b u =3 the upper bound estimate of the iteration period, which can be arbitrarily chosen, provided it is between the maximum number of nodes divided by the number of functional units and maximum nodes.  
         [0076]    b l =2 the lower bound estimate of the iteration period (8 nodes with 4 functional units)  
         [0077]    The objective function is given by the expression  
       Minimize   :       8          ∑     j   =   2     3          τ   j         +       ∑     p   =   1     2            ∑     t   =   1     8          x     8      pt           -       ∑     p   =   1     2            ∑     t   =   1     8          x     1      pt                                   
 
         [0078]    The precedence constraints are given by the expressions  
             ∑     t   =   1     8              t   ∑         p   2     =   1     2          x       i   2          p   2        t           -       ∑     t   =   1     8              t   ∑         p   1     =   1     10          x       i   1          p   1        t           -     d     i   2       +       n       i   1          i   2                ∑     j   =   2     3          j                   τ   j             &gt;   0                         
 
         [0079]    for load edges {2, 4, 5, 6, 9, 10, 11, 12, 15, 16, 18} 
           -       ∑     t   =   1     8          t          ∑       p   2     =   1     2          x       i   2          p   2        t               +       ∑     t   =   1     8          t          ∑       p   1     =   1     5          x       i   1          p   1        t             +       n       i   1          i   2                ∑     j   =   2     3          j                   τ   j                
     -       ∑     t   =   1     T            ∑       p   2     =   1     2          {         ∑       p   1     =   1     5          x       i   1          p   1        t         +     5        (     1   -     x       i   2          p   2        t         )       +     z       i   2          p   2        t         }           &gt;   0                         
 
         [0080]    for store edges {1,3,7,8,13,14,17} 
         [0081]    The job completion constraint is given by the expression  
             ∑     t   =   1     8            ∑     p   =   1       P   r            x   ipt         =   1     ,       for                 all                 nodes                 i     =   1     ,   2   ,   …              ,   15                         
 
         [0082]    The iteration period constraint is given by the expression  
           ∑     j   =   2     3          IP   j       =   1                         
 
         [0083]    The processor constraints are given by the expressions  
           ∑     i                 ɛ                   N   r                ∑     p   =   1     2                       ∑     s                 ɛ                   S   n              x   ips           &lt;       P   fu     +       (       P   fu     +   1     )          (     1   -     τ   2       )                               
 
         [0084]    for S 0 ={1,3,5,7} S 1 ={2,4,6,8} 
         [0085]    N a {1,2,7,8} additions  
         [0086]    N m ={3,4,5,6} Multiplications  
         [0087]    N r ={9,10,11,12,13,14} load/store  
           ∑     i                 ɛ                   N   r                ∑     p   =   1     2                       ∑     s                 ɛ                   S   n              x   ips           &lt;       P   fu     +       (       P   fu     +   1     )          (     1   -     τ   3       )                               
 
         [0088]    for S 0 ={1,4,7}, S 1 ={2,5,8} S 2 ={3,6} 
         [0089]    N a ={1,2,7,8} additions  
         [0090]    N m ={3,4,5,6} Multiplications  
         [0091]    N r ={9,10,11,12,13,14} load/store  
         [0092]    The load constraints are given by the expressions  
           ∑       t   2     ,       t   1        ε                 L                ∑       p   2     =   1       P   2                       {         ∑       p   1     =   1       P   1                       x       i   1          p   1        t         +       b     p   2            (     1   -     x       t   2          p   2        t         )       +     z       t   2          t   1          p   2        t         }         ≤   1                         
 
         [0093]    where p 1 , p 2  belongs to different sides  
         [0094]    The linearization process adds the following constraints to the MIP  
           z       i   2          p   2        t       +       ∑       p   1     =   1       P   1                       x       i   1          p   1        t         -       b     p   2            (     1   -     x       i   2          p   2        t         )         ≥   0                         
 
         [0095]    and z i     2     p     2     t ≧0 for all store edges {1,3,7, 8,13,14,17}, for all FUs and t=1,2, . . . , 8  
           z       i   2          i   1          p   2        t       +       ∑       p   1     =   1       P   1                       x       i   1          p   1        t         -       b     p   2            (     1   -     x       i   2          p   2        t         )         ≥   0                         
 
         [0096]    and z i     2     i     1     p     2     t ≧0 for edges {2,4,5,6,15,16,18} for all FUs and t=1,2, . . . , 8  
         [0097]    These equations are representative of equation sets which, when taken individually, can be solved using any known commercially available Integer Program solver operating on a computer having a central processing unit and memory. One of ordinary skill in the art would appreciate that, with the equations given above, equation sets can be derived that act as inputs to commercially available IP solvers and that results in outputs which detail a combined schedule and map of the algorithm onto the processor architecture.  
         [0098]    The results of the process are shown in Table 1. The optimal iteration period is calculated to be 3, with the nodes scheduled as shown in Table 1. Time slots T1, T2, and T3 represent the three periods and the nodes are listed thereunder. It should be noted that node 8 from the previous iteration (the previous iteration is represented by the −1 superscript notation) is processed at the same time as nodes 3 and 5 from the following iteration. The far left hand column represents the functional units performing the iterated functions. Based on this, the DSP algorithm can readily be programmed.  
                                                       TABLE 1                           Combined Schedule for 2 nd  Order IIR Filter for C6X                T1   T2   T3                            .M1   3 1     4 1                 .M2   5 1     6 1             .L1       1 1     2 1             .L2        8 −1         7 1                        
 
         [0099]    In a second embodiment, the invention is used to schedule and map a digital signal processing algorithm onto a StarCore SC 140 VLIW processor. The scheduling of parallel instructions is, as aforementioned, directed by the architecture of the DSP. As shown in FIG. 4, the simplified data path  400  of the StarCore processor has four FUs  410  and a 40-bit register file  420 , which has sixteen registers [not shown individually]. All the FUs  410  are same, containing an ALU with a MAC and a bit operation unit. Thus, any operation can be assigned to any FU  410 . This type of architecture is homogeneous and presents less scheduling constraints.  
         [0100]    As previously discussed, in the scheduling process the iteration period and the periodic throughput delay must be minimized. In this embodiment, however, cross-path communication is not an issue, because of a different architecture relative to the previously examined processor. As such, the equations and constraints differ from the previously discussed exemplary application.  
         x   it     =     {               1         node                 i                 is                 scheduled                 at                 time                 t             0                    otherwise                         i     =   1     ,   2   ,   …              ,   N   ,     t   =   1     ,   2   ,   …              ,   T                             
 
         [0101]    N=Number of operation nodes in the FSFG,  
         [0102]    T=Number of time classes considered  
         [0103]    The necessary objective function to be minimized is  
         T          ∑     j   =     b   l         b   u                       j                   τ   j           +       ∑     t   =   1     T                     x   ot       -       ∑     t   =   1     T                     x   it                             
 
         [0104]    where o=output node and i=input node  
         [0105]    Precedence constraints are determined by modeling processor behavior. In this case, where node i 1  precedes node i 2 , a precedence constraint is established, shown as  
             ∑     t   =   1     T                     tx       i   2        t         -       ∑     t   =   1     T                     tx       i   1        t         -     d     i   2       +       n       i   1          i   2                ∑     j   =     b   l         b   u                       j                   τ   j             &gt;   0                         
 
         [0106]    for all edges e(i 1 →i 2 )εE where node i 1  must be scheduled before node i 2 . The variables b l  and b u  represent the lower and upper bounds of iteration period, τ and n i     1     i     2    is the number of ideal delays on Edge e(i 1 →i 2 )εE.  
         [0107]    The job completion constraints are set by the requirement that all nodes must be scheduled as:  
             ∑     t   =   1     T                     x   it       =   1     ,       for                 all                 nodes                 i     =   1     ,   2   ,   …              ,   N                         
 
         [0108]    Since only one iteration period is to be selected out of a range of iteration periods, the iteration period equation is:  
           ∑     j   =     b   l         b   u                       τ   j       =   1                         
 
         [0109]    As previously noted, the processor being used has 4 identical FUs. Therefore, at any given point in time, each of the FUs can be concurrently scheduled.  
           ∑     s                 ɛ                   S   n              x   is       &lt;     4   +     M        (     1   -     τ   j       )                               
 
         [0110]    for i=1,2, . . . , N n=0,1, . . . , b u −1, S n =={s|s mod b u =n} 
         [0111]    M should be greater than 4 so that either-or-constraint condition is met.  
         [0112]    N=set of nodes mapped on the FU.  
         [0113]    x it ε{0,1 for all i=1,2, . . . , N, and t=1,2, . . . , T  
         [0114]    As a practical example, where a 5 th  order digital filter needs to be mapped onto the StarCore processor, a FSFG is generated, with nodes and dependencies defined. Once complete, representative expressions and constraints are determined. In this case:  
         [0115]    i=1,2, . . . ,26, t=1,2, . . . , 20  
         [0116]    The objective function is given by the expression:  
         20          ∑     j   =   10     15          j                   τ   j           +       ∑     t   =   1     20          x     34      t         -       ∑     t   =   1     20          x     1      t                               
 
         [0117]    Operation Precedence Constraints are given by the equation:  
           ∑     t   =   1     20          tx       1   2        t         -       ∑     t   =   1     20          tx       i   1        t         -     d     i   2       +       n       i   1          i   2                ∑     j   =   10     20          x     1      t                                 
 
         [0118]    Job completion constraints are given by the expression:  
             ∑     t   =   1     20          x   it       =   1     ,                  for                 all                 nodes                 i     =   1     ,   2   ,   …              ,   26                         
 
         [0119]    Iteration period constraints are given by the expression:  
           ∑     j   =   10     15          τ   j       =   1                         
 
         [0120]    FU constraints are given by the expression:  
           ∑     s                 ɛ                   S   n              x   is       &lt;     4   +     5        (     1   -     τ   j       )                               
 
         [0121]    for i=1,2, . . . , 26 n=0,1, . . . , b l −1.S n ={s|s mod b l =n} 
         [0122]    0-1 Constraints are given by the expression:  
         [0123]    x it ε{0,1 for all i=1,2, . . . , 26, and t=1,2, . . . , 20  
         [0124]    The expressions can be solved with any known, commercially available Integer Program solver. One of ordinary skill in the art would appreciate that, with the equations given above, equation sets can be derived that act as inputs to commercially available IP solvers and that results in outputs which detail a combined schedule and map of the algorithm onto the processor architecture.  
         [0125]    The resulting schedule of 5 th  order digital wave filter is shown in Table 2. The optimal iteration period is calculated to be 10, with the nodes scheduled as shown in Table 2. Time slots T1 through T10 represent the ten periods and the nodes are listed thereunder. It should be noted that nodes 24, 25, and 11 from the previous iteration (the previous iteration is represented by the −1 superscript notation) is processed at the same time as node 2 from the following iteration. The far left hand column represents the functional units performing the iterated functions. Based on this, the DSP algorithm can readily be programmed.  
                                                                                                           TABLE 2                           Optimal Schedule of 5th order digital wave filter on StarCore                T1   T2   T3   T4   T5   T6   T7   T8   T9   T10                        DALU1   2   6   13   14   12   7   20   21   22   23       DALU2   24 −1     19           15   17   5   26   1   3       DALU3   25 −1                     18       8   9   4       DALU4   11 −1                                 16   10                  
 
         [0126]    The foregoing description of a preferred implementation has been presented by way of example only, and should not be read in a limiting sense. Although this invention has been described in terms of certain preferred embodiments, namely in terms of two specific processor types, other embodiments that are apparent to those of ordinary skill in the art, including embodiments which do not provide all of the benefits and features set forth herein, are also within the scope of this invention.