Abstract:
A method for applying a computation utilizing a processor ( 112 ) capable of accessing an on-chip memory ( 114 ) and data from an off-chip source ( 116 ), the method comprising the iterative steps of retrieving at the on-chip memory ( 114 ) successive frames of input data from the off-chip source ( 116 ); computing from a current input frame of data ( 30 ) available in the on-chip memory current result elements for completing a current output frame of results ( 33, 34, 35 ), and pre-computing from the current frame of input data future result elements for contributing to at least one future output frame of results.

Description:
FIELD OF THE INVENTION 
   The present invention relates to high speed low latency computing using on and off-chip memory, and in particular low latency convolution of digital signals. In a preferred embodiment an efficient form of convolution suitable for use on a processor architecture that includes a limited quantity of memory with access time comparable to the processor cycle time and a main memory with an access rate significantly lower than the processor instruction execution rate is described. 
   BACKGROUND OF THE INVENTION 
   U.S. Pat. No. 5,502,747 entitled “Method and apparatus for filtering an electronic environment with improved accuracy and efficiency and short flow-through delay” filed by the present applicant, discloses a convolution filter having low latency and also having the ability to perform long convolutions. 
   Modern DSP algorithms are normally implemented on a digital signal processor such as the Motorola 56300 family, or (increasingly often) on general purpose microprocessors or custom or field-programmable integrated circuits (ASICs or FPGAs). Modern processor architectures normally have limited on-board memory resources and, as such, these resources must be managed efficiently, especially when off-chip memory access often incurs a relatively high overhead penalty, in that “wait states” are often incurred. 
   A wait-state is a processor state in which the processing element does nothing while it waits for a value to be read from or written to external memory. There may be more than one wait-state associated with each off-chip memory access. It is a characteristic of typical on-board memory systems that they induce fewer wait-states than off-chip memory, or none. 
   It would therefore be desirable to provide for an efficient form of convolution process which is amenable to a high speed implementation on such processor architectures. 
   SUMMARY OF THE INVENTION 
   It is an object of the present invention to provide for high speed, low latency computing which requires the usage of both on-chip memory and data from off-chip sources such as off-chip memory. In one version, the computation is in the form of a convolution which is implemented on DSP architecture. The computation is to be applied, repeatedly, to portions of data, in sequence. The advantageous nature of embodiments of the invention is apparent when succeeding portions of data are not available for processing until, or just before, the results that correspond to that data are required. This is commonly referred to as a “real-time” data processing system. 
   In accordance with a first aspect of the present invention there is provided a method for applying a computation utilising a processor capable of accessing an on-chip memory and data from an off-chip source, the method comprising the iterative steps of: 
   (a) retrieving at the on-chip memory successive frames of input data from the off-chip source; 
   (b) computing from a current input frame of data available in the on-chip memory current result elements for completing a current output frame of results, and 
   (c) pre-computing from the current frame of input data future result elements for contributing to at least one future output frame of results. 
   Step (b) preferably comprises combining the computed current result elements with result elements pre-computed from at least one preceding frame of input data to complete the current output frame of results. 
   Advantageously, the future output frame of results requires at least one input data frame which has not yet been retrieved from the off-chip memory for completion. 
   In a preferred embodiment, the method comprises the step of breaking up an algorithm for computing from the current input frame of data the current result elements into different algorithm execution phases, and further comprising the iterative steps of: 
   computing from the current input frame of data the current result elements for completing the current output frame of results stored in a current result buffer by applying a different one of the algorithm execution phases to each of respective partitions of the current result buffer, 
   pre-computing from the current frame of input data future result elements for contributing to at least one future output frame of results, and 
   storing the future result elements in at least one future result buffer, the at least one future result buffer being partitioned in the same way as the current result buffer. 
   Each partition of the current result buffer preferably has a different one of the algorithm execution phases applied to it from one iteration to another, and such that all algorithm execution phases are applied to each partition before one of the algorithm execution phases is re-applied to that partition. 
   The algorithm execution phases preferably include a phase of setting all terms of the partition, and at least one phase of updating one term of the partition. 
   The algorithm execution phases may further include at least one phase of updating multiple terms of the partition. 
   In accordance with a second aspect of the present invention, there is provided a method for applying a computation that accesses more data than would fit into a high-speed on-chip memory of a digital signal processor, including the step of accessing successive frames of input data, wherein the average access speed of the data by the processor is between the on-chip memory access speed and the off-chip memory access speed, and wherein the inherent algorithmic or computational latency of each successive result is less than an average acquisition time of a single frame of input data. 
   Preferably, the method comprises the steps of computing current results using the data currently resident in the on-chip memory, and computing partial results for at least one successive future frame of results by using at least some of the same current data. 
   In the first or second aspects, the on-chip memory may include a set of constant coefficients associated with the computation. 
   In the first or second aspects, the method may be applied to a segmented impulse response frequency domain convolution algorithm computation. 
   In accordance with a third aspect of the present invention there is provided a system for applying a computation comprising means for retrieving at an on-chip memory successive frames of input data from an off-chip source; a processor arranged, in use, to compute from a current input frame of data available in the on-chip memory current result elements for completing a current output frame of results, and wherein the processor is further arranged, in use, to pre-compute from the current frame of input data future result elements for contributing to at least one future output frame of results. 
   Preferably, the processor is arranged to combine the computed current result elements with result elements pre-computed from at least one preceding frame of input data to complete the current output frame of results. 
   Advantageously, the future output frame of results requires at least one input data frame which has not yet been retrieved from the off-chip memory for completion. 
   In one preferred embodiment, the system is arranged such that, in use, an algorithm for computing from the current input frame of data the current result elements is broken up into different algorithm execution phases, and the processor is arranged, in use, to execute the iterative steps of computing from the current input frame of data the current result elements for completing the current output frame of results stored in a current result buffer by applying a different one of the algorithm execution phases to each of respective partitions of the current result buffer, pre-computing from the current frame of input data future result elements for contributing to at least one future output frame of results, and storing the future result elements in at least one future result buffer, the at least one future result buffer being partitioned in the same way as the current result buffer. 
   Preferably, the processor is arranged, in use, such that each partition of the current result buffer has a different one of the algorithm execution phases applied to it from one iteration to another, and such that all algorithm execution phases are applied to each partition before one of the algorithm execution phases is re-applied to that partition. 
   Advantageously, the algorithm execution phases include a phase of setting all terms of the partition, and at least one phase of updating one term of the partition. 
   The algorithm execution phases may further include at least one phase of updating multiple terms of the partition. 
   The system may further comprise one or more of a group of the on-chip memory, the of-chip source, and the current result buffer, and the at least one future result buffer. 
   In accordance with a fourth aspect of the present invention, there is provided a data storage medium having stored thereon computer readable data for instructing a computer to execute a method according to the first or second aspects. 
   The system may be arranged, in use, to execute a segmented impulse response frequency domain convolution algorithm computation. 

   
     BRIEF DESCRIPTION OF THE DRAWINGS 
     Notwithstanding any other forms which may fall within the scope of the present invention, preferred forms of the invention will now be described, by way of example only, with reference to the accompanying drawings in which: 
       FIG. 1  illustrates one form of standard DSP architecture suitable for utilization with the algorithm of the preferred embodiment. 
       FIG. 2  illustrates the basic segmented low-latency convolution algorithm described in U.S. Pat. No. 5,502,747. 
       FIG. 3  illustrates the memory layout for the delay-line data and coefficients. 
       FIG. 4  illustrates the core computation of the BufMac loop and shows how partial results of future results can be computed with data available at a particular time (i) in an embodiment of the invention. 
       FIG. 5  illustrates the state of a result buffer for a number of different frames when utilizing the algorithm of one preferred embodiment, and 
       FIG. 6  illustrates the state of a result buffer for a number of different frames when utilizing the algorithm of another preferred embodiment. 
   

   DETAILED DESCRIPTION OF THE EMBODIMENTS 
   The various values used in the computation of preferred embodiments can be categorized into several distinct sorts, and making these distinctions will aid the explanation: 
   1. Input and output data: this is the signal to be processed, and the result of said processing. Input data is typically available in batches as the result of the transduction of some physical process, such as the vibrations of air pressure in the vicinity of a microphone. Output data is typically required immediately, for transduction to a physical process, such as the imparting of vibrations to air by a set of loudspeaker drivers. The number of discrete values available in the batches may be as few as one, but it is common to have sufficient temporal slack to be able to contrive for these values to be buffered into frames of some size, and we shall designate the number of “sample” periods that the data represents as “N”. 
   2. Coefficients: these are the values that are consistent from the application of the computation to one frame of N sample values to the next. The coefficients can be thought of as part of the machinery of the computation, in that it is they, along with the program code that executes on the processor, that determine the specific function that is computed. On the other hand, they are also like input/output data and state, in that they are often stored in the same sort of memory, and therefore subject to the same wait-state constraints. 
   3. State values: these are values that depend on the history of previously-observed input data, and may consist merely of stored values of that older data, or may be some arbitrary function of that past input data. They many also be values that relate only to the machinery of the computation. 
   4. Temporaries values. Like state values, these are values that are either an internal mechanism of the computation or derived from the input data, in the process of computing the output data, but unlike state, these are not required to be maintained from one application of the computation to the next. 
   The total memory space occupied by buffers for the input and output data, the coefficients, the system state and the temporaries are referred to as the “memory footprint”, and it is assumed for the purposes of this invention that this total space is significantly larger than the fast, on-board memory that is available to the processor. 
   Apart from the aforementioned patent, (U.S. Pat. No. 5,502,747), another prior-art technique is often referred to as “cache-blocking”. The general idea of blocking is to get the information to a high-speed storage and use it multiple times so as to amortize the cost of moving the data. Cache blocking operates to change the order of computation of terms of an overall computation so that more than one operation can be performed on each value fetched from memory. 
   That way, the computations after the first do not suffer the wait-states associated with the data&#39;s previous location in off-board memory, and so the total number of wait-states required to execute the computation is reduced. It follows that a prerequisite for cache blocking is a computation that uses some of its data and state values more than once. The direct implementation of the method of U.S. Pat. No. 5,502,747 does not offer an opportunity to apply this technique, because each coefficient is used only once to produce each new frame of output. It can be seen that if the technique is applied to non-real-time data, where all of the input signal is available at once, then cache-blocking could be applied, as each coefficient is re-used for each frame of output. 
   In many computations, each frame of output also requires a state value that corresponds to M previous frames of input data, which is another avenue for re-use. It would be possible to arrange to compute several (“P”) frames of output at once, on the basis of several (P) frames of input, and arrange the computations so that cache-blocking was effected, and the number of wait-states required to access the coefficients and the state could be reduced by as much as a factor of P. However, this suffers a latency increase associated with the processing of P frames at once. 
   The invention described herein is a way of achieving a measure of cache-blocking as described in the previous paragraph, while not suffering the latency increase that operating on P frames of data at once would require. It is therefore applicable to realtime operation. 
   The preferred embodiment relies upon a modified form of algorithm which is similar to that disclosed in detail in the aforementioned specification of U.S. Pat. No. 5,502,747, the contents of which are hereby specifically incorporated by cross-reference. 
   Turning first to  FIG. 1 , the method of the preferred embodiment operates on computing hardware that includes a DSP  110  having a processing element or core  112  that can perform both a memory fetch and a multiply-accumulate instruction in one processor clock cycle. A closely coupled “on-chip” 6144 (6 k), 24 bit words memory  114  introduces no wait-states and an “off-chip” static RAM 262144-word (256 k-word) memory  116  that introduces “W” wait-states for each access. A Direct Memory Access (DMA) engine  118  transfers data from the off-chip memory  116  to the on-chip memory  114  in P=W+2 processor cycles per word without interfering with the concurrent operation of the processor, via an external multiplexer bus  120 . 
   In addition, all of the requirements and software are provided for the original implementation of the algorithm disclosed in the aforementioned US patent, hereinafter known as the Low Latency Convolution algorithm. Specifically, the steps from the original algorithm comprising: 
   1. Acquire one block of N samples of input data for one channel, x i . (Item  2  in  FIG. 2 .) 
   2. Form x=x i−1 +j x i , where x i−1  is the input data acquired in the previous time frame (item  1  in  FIG. 2 ). 
   3. Compute X i =FFT(diag(w twist ).x) (item  4  in FIG. A 1 ), where w twist  are the “twist” factors, (item  5  in  FIG. 2 ) 
   4. Compute Y=BufMac(X, H) where H are the coefficients for output Y, for each output, (dotted-region in  FIG. 2 ). That is: 
             Y   ⁡     [   k   ]       =         ∑     M   -   1         j   =   0       ⁢         X     i   -   j       ⁡     [   k   ]       ⁢       H   j     ⁡     [   k   ]                 
for all k indices of elements of Y, Xi and Hj, usually i in [0, N−1].
 
   5. Repeat steps 1 to 4 for each input channel, accumulating the results for each output channel into a single result Y for each output channel. (only one input channel shown as such in  FIG. 2 ) 
   6. Compute y=imag(diag(w twist )′. FFT(Y)′) for each output channel, and send these values to the output mechanism. (arc connecting  14  and  3  in  FIG. 2 ) 
   Returning to  FIG. 1 , the on-chip memory  114  need only be large enough to hold the following:
         2N complex words of data, being only necessary pre- or postmultiplication factors and the Fast Fourier Transform (FFT) buffer used to implement the original algorithm. That is, x and X in one block of N complex values, w twist  and the FFT twiddle factors in blocks of N/2 complex values each; (items  4 ,  5  and  6  in  FIG. 2 )   4M(1+n OUT) complex words of data, arranged as two equal blocks with alignment such that modulo-2M addressing modes work for the first 2M words of each block. The blocks are further arranged so that a DMA engine can write to one block whilst the processor reads from the other without causing any memory access contention delays for either. “n OUT ” is the number of separate coefficient vectors that are to be convolved with the input stream to produce concurrently a corresponding number of resulting output signals.       

   For example, with M=12, (corresponding to a BufMac operation that computes one block of output on the basis of the current and eleven saved blocks of input, and twelve blocks of coefficients, and n OUT =2 for (say) left and right speaker outputs, we have twelve data values and 24 coefficient values, all complex, to compute output for a single frequency bin. That is storage for 72 words, with a modulo-2 addressing alignment requirement of 24-word alignment, which is achieved by starting the block at a multiple-of-32 address. We use two such blocks for the DMA double-buffering operation. If we use a Motorola DSP56300-series processor, on-chip memory is divided into 256-word chunks by the bus arbitration mechanism, so we must ensure that each of our two 72-word blocks lie entirely in separate 256-word pages, so that the central processor and the DMA engine do not contend for access to these memories; 
   The arrangement of data and coefficients in memory in one embodiment is illustrated in  FIG. 3 , for ease of access in inner loop of BufMac algorithm. 
   It is also possible to interleave the coefficients H for each output channel, if the processor has sufficient accumulator resources to compute multiple result complex dot-products at the same time. It may also be desirable to store the delay line data X in a disjoint memory space from H, so that the delay-line can be implemented as a (or several) circular buffer(s), thus avoiding the many write operations required to implement the delay lines in-place. It is also possible to not store the Xi values until performing the delay operation, because these will be present in the FFT buffer at the time that BufMac is executed.
         Approximately 200 words of working storage for the algorithm;   The program, which may be stored in a separate program memory  122 .       

   In the original algorithm, the IO buffers (items  1 ,  2 ,  3  in  FIG. 2 ), result buffer (item  14 ) and BufMac structure (item  15 ) are typically stored off-chip. The present invention, in at least preferred embodiments, seeks to optimise the access to the BufMac structure, which can contain significant amounts of data as outlined above and thus cause significant delays in the original algorithm. 
   The following terms are utilized in the preferred embodiment, with reference again to  FIG. 2  for illustration of the overall process. 
   FFT Buffer represents the storage of N complex words (i.e. 2N words) used as working storage by the computation of the algorithm. Item  4  in  FIG. 2 . That will hold the N new data values and the N old data values, the result of the twist multiplication, which can be performed in-place, and the argument and result of the FFT operation, which can also be performed in-place. 
   N represents the number of new samples consumed by the overlap-save filtering algorithm. It also denotes the size (number of complex input and output values) of the Fast Fourier Transform (FFT) and Inverse Fast Fourier Transform (IFFT) performed by the algorithm, as well as the computation latency of the algorithm. It is a fundamental parameter of the overlap-save filtering algorithm described in the six numbered steps above. 
   M represents the number of terms of the frequency-domain FIR algorithm that comprises the central portion of the Low-Latency convolution algorithm (also known as the BufMac kernel). This is the number of X blocks (and H blocks for each channel) shown in  FIG. 2  as  4 ,  7 ,  8 ,  9  and  10 ,  11 ,  12 ,  13  respectively. 
   P represents the ratio between the rate at which the DMA engine can copy values from off-chip memory to on-chip memory and the rate at which the processor can consume these values while computing a complex multiply-accumulate loop (generally one per instruction cycle). This is the number of times off-chip data has to be used each time it is fetched from off-chip memory. In contemporary high performance processor hardware, P has a value in the range 2 to on the order of 10. It is easily possible (though not desirable) to arrange for the memory system to be even slower, with respect to the processor, resulting in a P value much larger than 10. 
   IO Buffer(s) These are the time-domain (circular) buffers used to pass signal data to and from the analog section (CODECs). It does not play a significant role in this description, but is part of the underlying Low Latency Convolution algorithm. Shown in  FIG. 2  as blocks  1 ,  2 , and  3 . 
   Result Buffer(s) These are frequency domain buffers used to store complete and partial results of the algorithm described here. Storage is required for P times n OUT  blocks of N complex words. This storage may be off-chip because of space constraints a situation similar to the one for the original algorithm. Shown in  FIG. 2  as block  14 . 
   Frequency domain delay line and coefficient (BufMac) data structure This is an array of blocks of memory (shown as blocks  7  to  13  in  FIG. 2 ) that are used to store the time series of frequency-domain signal data and filter coefficients. For each of N frequency bins, there are (1+n OUT ) blocks of M complex values. The factor (1+n OUT ) provides for a block for the signal data and n OUT  blocks for the (multiple) sets of filter coefficients. This arrangement is used so that memory access during the “BufMac” processing is essentially linear, which maximizes the performance of off-chip memory for most practical memory system designs. Shown for n OUT =2 in  FIG. 3 . 
   Processing Steps This process is repeated for every N input samples, and produces n OUT  streams of N output samples corresponding to the convolution of the preceding N by M input samples with the same number of coefficients. Coefficients are loaded into the BufMac data structure using a separate process described below. The process includes the following steps: 
   (a) Upload This is identical to the original Low-Latency Convolution algorithm. The last N signal samples read by the previous Upload pass and the next N signal samples are simultaneously read from the IO Buffer and multiplied as the real and imaginary parts (respectively) point-for-point with any premultiplication factors. The N resulting complex values are stored in the FFT Buffer. 
   (b) Fourier Transform The contents of the FFT Buffer are processed in-place by a Fast Fourier Transform routine, which replaces the pre-multiplied signal data with a frequency-domain signal representation. 
   (c) Segmented impulse response frequency domain convolution step (BufMac) This is the process of accumulating the complex products of each frequency bin of the signal with the corresponding bin of coefficients, for each time lag in [0, (M−1)], and it is described more fully below. Unlike the previous algorithm, this process leaves n OUT  sets of results in one of the P sets of Result buffers. The Result buffer used is the one after the one used on the previous iteration (modulo P). 
   (d) Inverse Fourier Transform Each of the “current” n OUT  Result buffers is copied into the FFTBuffer, where an inverse Fourier Transform operation is performed on it, to transform it into a time domain representation. 
   (e) Download After each of the n OUT  signals are transformed (in the previous step), they are multiplied point-by-point with any post-multiplication. The imaginary part of the N resulting complex values are stored in the corresponding IOBuffer as the next N output values for that output channel. 
   Coefficient Loading To initialise the frequency domain coefficients in the BufMac structure from a time-domain impulse response it is necessary to divide the impulse response into M blocks of N coefficients, and with each block in turn:
         Perform the upload function on the concatenation of the coefficient block padded to length 2N with zeros.   Compute the FFT of this result, observing that the scaling will be different than that used for processing potentially full-scale signals, if fixed-point processors are used.   Store data in BufMac structure, proceeding through the M blocks of coefficients.       

   Differential Memory Bandwidth Tolerant Segmented Impulse Response Frequency Domain Convolution Algorithm (New BufMac) 
   The new BufMac is significantly different from the simple expression of the corresponding stage of the original Low-Latency Convolution algorithm. 
   Part of this complexity is brought about by a desire to use the minimum on-chip memory possible (a requirement forced by available DSP processor chips). Most of the complexity is introduced by the need to use the DMA engine to transfer the data and coefficient values from off-chip memory to on-chip memory without having the processor introduce a pipeline stall for the wait-states, and from the need to use these values more than once, to keep the processor usefully busy. 
   The throughput constraint can be re-worded as “the processor is not waiting for slow memory while summing terms of the BufMac expression.” Avoiding having to wait for memory is achieved in part by arranging to pre-fetch the coefficients and data required to compute a result for each frequency bin. 
   With a DMA engine, such as the one built into the Motorola DSP56300 series of DSPs, it is possible to perform this pre-fetch operation in parallel with a computation that is operating on a previously fetched block of coefficients and data. Alternatively, many modern microprocessors, such as the Intel Pentium-4 and Itanium have “prefetch” instructions that instruct the memory system to load values into the cache before they are needed as arguments of an instruction. 
   Consequently, the X and H values described in the following description do not refer directly to those values as stored off-chip in the BufMac data structure, but rather to on-chip copies that can be accessed without wait-states or pipeline stalls. 
   On its own, pre-fetching does not achieve the throughput goal, because it takes P times as long to fetch each block of data and coefficients from memory as it does to compute the corresponding result. The goal of the new algorithm in an embodiment of the invention, therefore, is to compute as many of the result values that will be needed in the P−1 succeeding frames as possible, given the existing data This is illustrated in  FIG. 4 , together with the relevant equations. 
   In  FIG. 4 , the currently available data  30  and the coefficients  32  are used to calculate results for a single frequency bin of the BufMac, that is result terms  33 ,  34 ,  35  can be computed with the data available in the current frame i, with terms  34 ,  35  being computed with the data available in frame i in anticipation of their use in frames i+1 and i+2 respectively. Also shown in  FIG. 4  is the data available at frame i+1,  36 , and i+2,  37 . 
   It has also been recognised that one can make more use of the X values that we have loaded into on-chip memory by also computing results for multiple output signals, corresponding to multiple coefficient sets. It is a question of collocating the multiple coefficient sets with the corresponding data values so that a simple block transfer operation by the DMA/prefetch engine will bring all of the values in at once. 
   To complete the calculation of Y i . . . Y{i+P−1}, in the succeeding frames, it is only necessary to compute the first term of the right hand side of the equations in  FIG. 4  and add it to the partial result computed and stored by a previous calculation of equation 2 (computed when that data was first available). This part of the process is referred to as “the block update algorithm”, and is now described in more detail. 
   The number of terms computed at the full processor speed will be 
   
     
       
         
           MP 
           - 
           
             
               P 
               ⁡ 
               
                 ( 
                 
                   P 
                   - 
                   1 
                 
                 ) 
               
             
             2 
           
         
       
     
   
   and the number computed at the memory speed will be 
   
     
       
         
           
             P 
             ⁡ 
             
               ( 
               
                 P 
                 - 
                 1 
               
               ) 
             
           
           2 
         
       
     
   
   Averaged over P frames, the number of processor cycles per frame consumed by the algorithm is 
   
     
       
         
           
             ( 
             
               M 
               + 
               
                 
                   ( 
                   
                     P 
                     - 
                     1 
                   
                   ) 
                 
                 ⁢ 
                 
                   ( 
                   
                     P 
                     - 
                     2 
                   
                   ) 
                 
               
             
             ) 
           
           2 
         
       
     
   
   whereas the direct implementation requires 
   (P−1) M cycles, assuming that in this case accesses require only P−1=W+1 cycles, because without value re-use it is slower to use the DMA engine. 
   The algorithm requires M≧P, also its worst case behavior occurs when M=P, at which point the difference between the old and the new algorithms is 
             (       P   2     -   P   -   2     )     2         
cycles in favor of the new. (Note that this expression is zero when P=2, which corresponds to the zero-wait state case, for which the old algorithm is optimal).
 
   This much of the new algorithm achieves the throughput goal, but requires that the processor have close to a factor of P excess capability, in order to reach the latency goal. That is because for one frame in P it must compute most of the result terms for P consecutive frames, and do comparatively little work in the intervening frames. This is still a useful result, because in computing most of the terms for all P frames at once we have increased the processor&#39;s efficiency by nearly that factor of P, and so the saved cycles are available for other work, if there is other work to be done. 
   Another way of looking at this state of affairs is to say that with this much of the algorithm, we still require a processor that can perform the original computation in real-time despite the presence of wait-states. What we have achieved is that it sits idle for nearly P−1 out of P frames of input. 
   In the next section we describe how to more evenly distribute the workload through time, so that the processing load is even or nearly even for each frame, with the result that we can still meet both the throughput goal and the latency goal with a processor that is much slower than the original, or (conversely) we can perform a computation that is nearly P times as large on the same hardware, compared to one using the original algorithm and memory with wait-states. The solution to this problem in a preferred embodiment is to apply the block-computation algorithm and the block-update algorithms to alternating groups of frequency bins, as is described below. 
   Leveling the Computational load while meeting the Latency Constraint 
   As illustrated in  FIG. 5 , the computational load of pre-calculating the partial results for future frames can be shared across those frames by partitioning the set of frequency bins  40 ,  42 ,  44 , and assigning a different schedule of algorithm execution to each partition e.g.  46 , so that after P frames all of the partitions will have been processed by all stages of the algorithm. This implies that there is a P−1 frame start-up transient in which some result bins  40 ,  42 ,  44  will have an incorrect value, but after that a correct result will be present in every bin, for every frame. Consider the case where P=3 and n OUT =2, as is shown in  FIG. 4 . 
   Here P is not a factor of N and so the partitions will vary slightly in size, some smaller than 
             N     P   ·     n   OUT         ⁢           ⁢     (       specifically  floor       ⁢     N     P   ·     n   OUT           )     ⁢       some  larger       ⁢       (       specifically  ceil     ⁢           ⁢     N     P   ·     n   OUT         ⁢       bins       )     .           
bins). Care should be taken to ensure that the P.n OUT  simultaneously computed results for each bin can be efficiently updated, as this will be slightly larger than the FFT Buffer previously used by the algorithm. The number of partitions must be a multiple of P so that the complete sequence of computations can be performed without requiring dramatically different amounts of computation for each frame.
 
   EXAMPLE ALTERNATIVES 
   1. When the specifics of the computer hardware make it difficult to enlarge the FFT Buffer to accommodate the extra results mentioned above, the number of frequency bin partitions can be increased, in multiples of P. This incurs a proportionally higher cost in terms of loop and subroutine call overheads, but that may be small compared to the cost of writing the results directly back to off-chip memory. For example, if P=3, and n OUT =2, as above, but it is impossible to work on more than N result values at once, then the number of partitions must be at least nine. This will result in results filling approximately two-thirds of the FFTBuffer at the end of each partition. 
   2. The opposite limit to the size of a partition is also a useful working point: If each partition consists of a single frequency bin, then the different phases of the computation schedule are simply applied in sequence to successive bins. This simplifies the program logic, at the expense of some performance that might be lost because the next-to-inner loop is now more complicated. This problem can, in turn, be addressed by making each partition a small fixed number of bins, where the size of the partition is sufficient to satisfactorily amortize the loop startup overhead. 
   Schedule 
   To describe the processing schedule, consider that each of the iterations of the new algorithm are numbered, and the current frame number is i. Consider each of the frequency bin partitions to be numbered p∈[0, αP−1], for some cardinal α. In the examples that we have given above, has been n OUT  (when we used six partitions), n OUT =1 (when we used nine partitions) and 
           N   P         
(when we discussed using a partition size of one bin).
 
   Then at each frame, the processing applied to partition p of the current result buffer is:
         Full computation of current results for p (mod P)=i (mod P). That is:       

   
     
       
         
           
             
               ∑ 
               
                 M 
                 - 
                 1 
               
             
             
               j 
               = 
               0 
             
           
           ⁢ 
           
             
               X 
               
                 i 
                 - 
                 j 
               
             
             · 
             
               H 
               j 
             
           
         
       
     
       
       
         
           Update existing results with the first i−p (mod P) terms from the previous equation otherwise. 
           That is result=result+ 
         
       
     
  
                 ∑   k       j   =   1       ⁢       X     i   +   j       ·     H     k   -   j           ,         
where k=p (mod P) followed by output of that current result buffer.
         The processing applied to partition p of the result buffer for subsequent frame i&gt;j for j∈[1, P−1] is:   Partial computation of the result using available data. That is       
               ∑     M   -   1         k   =   j       ⁢       X     i   +   j   -   k       ·     H   k             
when p (mod P)=i (mod P) and no change to the state of the result buffer otherwise.
 
   The effect of this schedule (summarized in  FIG. 5  when P=3 and n out =2 ) is that each result bin will be computed in succeeding frames with the operations [“full”, “update one term”, . . . , “update P−1 terms”] in the time frame that it is to be output. All of the results in a given partition will be computed to the same schedule, but the terms in the next partition will be computed according to a schedule that has been rotated forwards by one: [“update P−1 terms”, “full”, “update 1 term”, . . . ]. After each of the results have been computed for each partition, the values can be stored in off-chip memory for subsequent processing steps. 
   In frames that a given result buffer will not be output, the only change made in that buffer is to the partition that is the same as the one receiving the “full” result in the current result buffer. In those partitions, the partial result computable with the available data is stored. 
     FIG. 6  shows an alternative schedule, in which the multi-term update operations are spread over succeeding iterations of the schedule, so that each update operation only involves a single term operation with the single new data value. 
   Whether this arrangement is advantageous or not depends on the relative cost of accessing the other data and coefficient values at the time that the update is performed, compared to the cost of the extra read and write operations to perform the extra updates in the result buffer. 
   It would be appreciated by a person skilled in the art that numerous variations and/or modifications may be made to the present invention as shown in the specific embodiments without departing from the spirit or scope of the invention as broadly described. The present embodiments are, therefore, to be considered in all respects to be illustrative and not restrictive. For example, it will be appreciated that the results from different input sources may be accumulated into a single set of result buffers, for a multi-input configuration.