# Patent

## Title
Memory-based FFT/IFFT processor and design method for general sized memory-based FFT processor

## Abstract

For a large size FFT computation, this invention decomposes it into several smaller sizes FFT by decomposition equation and then transform the original index from one dimension into multi-dimension vector. By controlling the index vector, this invention could distribute the input data into different memory banks such that both the in-place policy for computation and the multi-bank memory for high-radix structure could be supported simultaneously without memory conflict. Besides, in order to keep memory conflict-free when the in-place policy is also adopted for I/O data, this invention reverses the decompose order of FFT to satisfy the vector reverse behavior. This invention can minimize the area and reduce the necessary clock rate effectively for general sized memory-based FFT processor design.

## Background
BACKGROUND OF THE INVENTION
1. Field of the Invention
This invention relates to a memory-based FFT/IFFT processor and design method for general sized memory-based FFT processor to minimize the area and reduce the necessary clock rate.
2. Description of the Related Art
A. Prior Arts List:
1. USA Patent:













Pat. No.
Title







[A1]
4,477,878
Discrete Fourier transform with non-tumbled




output


[A2]
5,091,875
Fast Fourier transform (FFT) addressing




apparatus and method


[A3]
7,062,523
Method for efficiently computing a fast Fourier




transform


[A4]
7,164,723
Modulation apparatus using mixed-radix fast




Fourier transform


[A5]
20060253514
Memory-based Fast Fourier Transform device



(Publication No.)


[A6]
20080025199
Method and device for high throughput n-point



(Publication No.)
forward and inverse fast Fourier transform









2. China Patent:















Pat. No.
Title


















[A7]
01140060.9
The architecture for 3780-point DFT processor


[A8]
03107204.6
The multicarrier systems and method with




3780-point IDFT/DFT processor


[A9]
200410090873.2
The oversampling method for 3780-point DFT



(Publication No.)


[A10]
200610104144.7
The 3780-point DFT processor



(Publication No.)


[A11]
200710044716.1
The water-flowed 3780-point FFT processor



(Publication No.)









3. Articles

    [B1] Z.-X. Yang, Y.-P. Hu, C.-Y. Pan, and L. Yang, “Design of a 3780-point IFFT processor for TDS-OFDM,” IEEE Trans. Broadcast., vol. 48, no. 1, pp. 57-61, March 2002.
    [B2] L. G. Johnson “Conflict free memory addressing for dedicated FFT hardware,” IEEE Trans. Circuits Syst. II, Analog Digit. Signal Process., vol. 39, no. 5, pp. 312-316, May 1992.
    [B3] B. G. Jo, and M. H. Sunwoo, “New continuous-flow mixed-radix (CFMR) FFT processor using novel in-place strategy,” IEEE Trans. Circuits Syst. I, Reg. Papers, vol. 52, no.5, pp. 911-919, May 2005.


B. Description of Prior Arts
(1) [A1] could not support the multi-bank memory structure. Hence, for the radix-r computation, it would cost r clock cycles to read data from memory and write the computed data back to memory. This would result in the FFT needs more computation cycle and thus demand higher clock rate for the processor for real-time application. This invention could solve this problem by supporting the multi-bank addressing without memory conflict such that the r data for radix-r could be accessed in one clock cycle.
(2) [A2], [A5], [B2] could only support the fixed radix-r. Hence, it could only be applied in the FFT with the size N=r If we consider the application that the 3780-point FFT for the Chinese DTV application or the 3072-point FFT for the PLC application, they would not work here. This invention could support any general mixed radix such that it could work for any size FFT application.
(3) [A3] could only support the fixed radix-r, hence, it could not support the Chinese DTV or PLC etc application. Besides, since it could not support multi-bank memory structure, it would need r clock cycles for data access from memory for radix-r computation. Then, it would need higher clock rate for FFT computation than the processor that takes multi-bank memory structure. This invention could not only support variable radix for any size FFT application but also support multi-bank memory structure to reduce necessary clock rate without memory conflict.
(4) [A4], [B3] could only support the radix-2/4 algorithm. Therefore, it could only work for the FFT with the size N=2n. And for the FFT application with the other size such as for the Chinese DTV with N=3780, it would not work. However, this invention could work for all of them since this invention could support any mixed radix. Besides, for the long size FFT processor design such as N=8192, this invention could make the processor design more flexible since the max radix [4] could support is only radix-4 and this invention could support is greater than radix-4.
(5) [A6] describes some candidate decomposition of 3780, for instance, 3780=3×3×3×2×2×5×7. It implements each small size FFT module with the MDC structure to eliminate some large internal buffer in [A7]-[A11]. But, this would cost more hardware since it should finish all the computation within one clock cycle for each module. Besides, for real system application, the in order output data is necessary. However, its output data are not in order output.
(6) [A7], [A8], [A9], [A10], [A11] implement the 3780-point FFT processor with some architecture which is similar to pipeline. Their architecture need large internal buffer to reorder the data for processing. Besides, for the real system application requirement, the in order I/O data and to support continuous data flow are both necessary. In order to achieve this, [A7], [A8] needs at least 3N words; [A9], [A11] needs at least 5N words; [A10] needs 6N words memory size. This invention could achieve this requirement only with 2N memory words. Note that, the output data of [A7], [A8] and [A11] are not in order output, and they need “at least” one N words memory to reorder the output data as in order output.
(7) The output data of the 3780-point FFT processor proposed in [B1] is not in order. In order to achieve this, it would need a buffer to reorder the output data. Hence, the design would need memory size more than 4N words to achieve continuous data flow and in order I/O data. However, this invention only needs 2N words memory.










Classification of the Prior arts












[A1]
[A2] [B2] [A5]
[A3]
[A4] [B3]















Radix *1
All general
Fixed radix-r
Fixed radix-r
Radix-2/4


In-place *2
Yes
Yes
Yes
Yes


Memory *3
2N words
2N words
2N words
2N words


Multi-bank *4
No
Yes
No
Yes





*1 The Tab “Radix” means that the butterfly size that the prior patents could support.


*2 The Tab “In-place” means that whether the prior patents support the in-place policy to reduce the necessary memory size.


*3 The Tab “Memory” means that the necessary memory size for the real-time application of the prior patents.


*4 The Tab “Multi-bank” means that whether the prior patent could support the multi-bank memory structure to reduce the necessary clock rate.






SUMMARY OF THE INVENTION
To overcome the drawbacks of the prior arts, this invention proposes a design method of general sized memory-based FFT processor, comprising the steps of: (1) Decomposing a large size FFT computation into several relative smaller sizes FFT by decomposition equation and then transform the original index from one dimension into multi-dimension vector; (2) Controlling the index vector to distribute the input data into different memory banks such that both the in-place policy for computation and the multi-bank memory for high-radix structure could be supported simultaneously without memory conflict; (3) In order to keep memory conflict-free when the in-place policy is also adopted for I/O data, reverses the decompose order of FFT to satisfy the vector reverse behavior; through the steps to minimize the area and reduce the necessary clock rate. This invention also proposes a memory-based FFT/IFFT processor comprising: a main memory to store data; a processing element for decomposed smaller sized FFT computation; a control unit to control: (1) the memory for I/O data and butterflies computation (2) the computation order of smaller sized FFT (3) the memory addressing for data access with in-place policy.



BRIEF DESCRIPTION OF THE DRAWINGS
FIG. 1. The design block of FFT processor of this invention.
FIG. 2. The index vector generator hardware implementation of this invention.



DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENT
For the best understanding of this invention, please refer to the following detailed description of the preferred embodiments and the accompanying drawings.
The definition of DFT is




  
    X
    ⁡
    
      (
      k
      )
    
  
  =
  
    
      ∑
      
        n
        =
        0
      
      
        N
        -
        1
      
    
    ⁢
    
      
        x
        ⁡
        
          (
          n
          )
        
      
      ⁢
      
        
          W
          N
          nk
        
        .
      
    
  




The method to decompose a larger size DFT into several smaller sizes DFT has been proposed in article C1 [C. Burrus, “Index mappings for multidimensional formulation of the DFT and convolution,” IEEE Trans. Acoust., Speech, Signal Process., vol. 25, no. 3, pp. 239-242, June 1977]. Here, the present invention takes the decomposition equation (1) for the size N=N1N2 for illustration:





  
    
      
        {
        
          
            
              
                n
                =
                
                  
                    
                      N
                      2
                    
                    ⁢
                    
                      n
                      1
                    
                  
                  +
                  
                    
                      A
                      2
                    
                    ⁢
                    
                      n
                      
                        2
                        ⁢
                        
                          
                        
                      
                    
                    ⁢
                    mod
                    ⁢
                    
                      
                    
                    ⁢
                    N
                  
                
              
            
            
              
                
                  n
                  1
                
                ,
                
                  
                    k
                    1
                  
                  =
                  0
                
                ,
                1
                ,
                ...
                ⁢
                
                  
                
                ,
                
                  
                    N
                    1
                  
                  -
                  1
                
              
            
          
          
            
              
                k
                =
                
                  
                    
                      B
                      1
                    
                    ⁢
                    
                      k
                      1
                    
                  
                  +
                  
                    
                      N
                      1
                    
                    ⁢
                    
                      k
                      2
                    
                    ⁢
                    
                      
                    
                    ⁢
                    mod
                    ⁢
                    
                      
                    
                    ⁢
                    N
                  
                
              
            
            
              
                
                  n
                  2
                
                ,
                
                  
                    k
                    2
                  
                  =
                  0
                
                ,
                1
                ,
                ...
                ⁢
                
                  
                
                ,
                
                  
                    N
                    2
                  
                  -
                  1
                
              
            
          
        
      
    
    
      
        (
        1
        )
      
    
  




Eq. (1) maps the index n and k to the index vector (n1, n2) and (k1, k2), from one dimension [0, N−1] into two dimensions [0, N1−1]×[0, N2−1]. The selection of coefficient A2 and B1 depends on the relation between N1 and N2. In this invention, the coefficients for Eq. (1) are employed as follows:
Case I: If N1 and N2 are relative prime, we choose A2 and B1 such that

A2=p1N1 and A2=q1N2+1

B1=P2N2 and B1=q2N1+1

Here, p1, q1, p2 and q2 are all positive integers. Then, the definition of DFT could be rewritten as Eq. (2):




  
    
      
        
          
            
              
                X
                ⁡
                
                  (
                  
                    
                      k
                      1
                    
                    ,
                    
                      k
                      2
                    
                  
                  )
                
              
              =
              
                
                  ∑
                  
                    n
                    2
                  
                  
                    
                  
                
                ⁢
                
                  
                    ∑
                    
                      n
                      1
                    
                    
                      
                    
                  
                  ⁢
                  
                    
                      x
                      ⁡
                      
                        (
                        
                          
                            n
                            1
                          
                          ,
                          
                            n
                            2
                          
                        
                        )
                      
                    
                    ⁢
                    
                      W
                      
                        N
                        
                          1
                          ⁢
                          
                            
                          
                        
                      
                      
                        
                          n
                          1
                        
                        ⁢
                        
                          k
                          1
                        
                      
                    
                    ⁢
                    
                      W
                      
                        N
                        2
                      
                      
                        
                          n
                          2
                        
                        ⁢
                        
                          k
                          2
                        
                      
                    
                  
                
              
            
          
        
        
          
            
              =
              
                
                  ∑
                  
                    n
                    2
                  
                  
                    
                  
                
                ⁢
                
                  
                    {
                    
                      
                        ∑
                        
                          n
                          1
                        
                        
                          
                        
                      
                      ⁢
                      
                        
                          x
                          ⁡
                          
                            (
                            
                              
                                n
                                1
                              
                              ,
                              
                                n
                                2
                              
                            
                            )
                          
                        
                        ⁢
                        
                          W
                          
                            N
                            
                              1
                              ⁢
                              
                                
                              
                            
                          
                          
                            
                              n
                              1
                            
                            ⁢
                            
                              k
                              1
                            
                          
                        
                      
                    
                    }
                  
                  ⁢
                  
                    W
                    
                      N
                      2
                    
                    
                      
                        n
                        2
                      
                      ⁢
                      
                        k
                        2
                      
                    
                  
                
              
            
          
        
        
          
            
              =
              
                
                  ∑
                  
                    n
                    2
                  
                  
                    
                  
                
                ⁢
                
                  
                    y
                    ⁡
                    
                      (
                      
                        
                          k
                          1
                        
                        ,
                        
                          n
                          2
                        
                      
                      )
                    
                  
                  ⁢
                  
                    W
                    
                      N
                      2
                    
                    
                      
                        n
                        2
                      
                      ⁢
                      
                        k
                        2
                      
                    
                  
                
              
            
          
        
      
    
    
      
        (
        2
        )
      
    
  




Case II: If N1 and N2 are not relative prime, we choose A2=B1=1. Then, the definition of DFT could be rewritten as Eq. (3):




  
    
      
        
          
            
              
                X
                ⁡
                
                  (
                  
                    
                      k
                      1
                    
                    ,
                    
                      k
                      2
                    
                  
                  )
                
              
              =
              
                
                  ∑
                  
                    n
                    2
                  
                  
                    
                  
                
                ⁢
                
                  
                    ∑
                    
                      n
                      1
                    
                    
                      
                    
                  
                  ⁢
                  
                    
                      x
                      ⁡
                      
                        (
                        
                          
                            n
                            1
                          
                          ,
                          
                            n
                            2
                          
                        
                        )
                      
                    
                    ⁢
                    
                      W
                      
                        N
                        
                          1
                          ⁢
                          
                            
                          
                        
                      
                      
                        
                          n
                          1
                        
                        ⁢
                        
                          k
                          1
                        
                      
                    
                    ⁢
                    
                      W
                      
                        N
                        2
                      
                      
                        
                          n
                          2
                        
                        ⁢
                        
                          k
                          2
                        
                      
                    
                    ⁢
                    
                      W
                      N
                      
                        
                          n
                          2
                        
                        ⁢
                        
                          k
                          1
                        
                      
                    
                  
                
              
            
          
        
        
          
            
              =
              
                
                  ∑
                  
                    n
                    2
                  
                  
                    
                  
                
                ⁢
                
                  
                    {
                    
                      
                        W
                        N
                        
                          
                            n
                            2
                          
                          ⁢
                          
                            k
                            1
                          
                        
                      
                      ⁢
                      
                        
                          ∑
                          
                            n
                            1
                          
                          
                            
                          
                        
                        ⁢
                        
                          
                            x
                            ⁡
                            
                              (
                              
                                
                                  n
                                  1
                                
                                ,
                                
                                  n
                                  2
                                
                              
                              )
                            
                          
                          ⁢
                          
                            W
                            
                              N
                              
                                1
                                ⁢
                                
                                  
                                
                              
                            
                            
                              
                                n
                                1
                              
                              ⁢
                              
                                k
                                1
                              
                            
                          
                        
                      
                    
                    }
                  
                  ⁢
                  
                    W
                    
                      N
                      2
                    
                    
                      
                        n
                        2
                      
                      ⁢
                      
                        k
                        2
                      
                    
                  
                
              
            
          
        
        
          
            
              =
              
                
                  ∑
                  
                    n
                    2
                  
                  
                    
                  
                
                ⁢
                
                  
                    W
                    N
                    
                      
                        n
                        2
                      
                      ⁢
                      
                        k
                        1
                      
                    
                  
                  ⁢
                  
                    y
                    ⁡
                    
                      (
                      
                        
                          k
                          1
                        
                        ,
                        
                          n
                          2
                        
                      
                      )
                    
                  
                  ⁢
                  
                    W
                    
                      N
                      2
                    
                    
                      
                        n
                        2
                      
                      ⁢
                      
                        k
                        2
                      
                    
                  
                
              
            
          
        
      
    
    
      
        (
        3
        )
      
    
  




Eqs. (2) and (3) imply that a larger size N-point FFT could be computed by two smaller sized N1-point and N2-point FFT in the first and second stages respectively. For the fixed n2, the input data of the N1-point FFT in the first stage are x(n1, n2), n1=0, 1, . . . , N1−1. The output data of the first stage correspond to this n2 are y(k1, n2), k1=0, 1, . . . , N1−1. For the fixed k1, the input data of the N2-point FFT in the second stage are y(k1, n2), n2=0, 1, . . . , N2−1. The output data of the second stage correspond to this k1 are X(k1, k2), k2=0, 1, . . . , N2−1. The difference between Eq. (2) and (3) is that if N1 and N2 are not relative prime, there would have twiddle factor wNn2k1 between the first and second stages as shown in Eq. (3).
Now, the present invention considers computing N1-point DFT in the first stage and N2-point DFT in the second stage for the first DFT symbol. The present invention distributes the input data into different memory banks. Suppose N2≧N1 and the memory bank number is N2, then, the input data could be distributed into N2 memory banks by Eq. (4) to achieve memory conflict-free.

bank=n1+n2 mod N2   (4)

The key to achieve memory conflict-free is to distribute data into memory bank by Eqs. (1) and (4). Once the memory bank is selected, data need to be addressed. Any two data in the same memory bank should be mapped to different address within the range from 0 to N1−1. For simplicity, we choose Eq. (5) for data addressing.

address=n1   (5)

After finishing computing the first DFT symbol, the data should be outputted in order. The output index is mapped by Eq. (4). When the computed DFT symbol data are outputted in order, the input data of the second DFT symbol are also inputted in order simultaneously with the in-place policy. That is, the new input data x(i) should be put in the location of the output data y(i). For the computation of the second DFT symbol, the present invention computes it with the reverse order of the first DFT symbol. The present invention computes the N2-point DFT in the first stage and N1-point DFT in the second stage for the second DFT symbol. After finishing computing the second DFT symbol, the I/O data also adopts the in-place policy. The third DFT symbol would return to the state of the first DFT symbol.
The following, the present invention takes the 3780-point FFT as example for detailed illustration, which has been adopted for the Chinese DTV application. The decomposition order in following is only one of the candidate selections.
Since 3780=4×3×3×3×5×7, we could complete it by computing the 3-point, 4-point, 5-point and 7-point FFT respectively. Here, the data are distributed into 7 memory banks.
First, the present invention takes the decomposition order, 4, 3, 3, 3, 5 and then 7. For the first stage (4-point FFT), the decomposition equation (6) is taken.




  
    
      
        {
        
          
            
              
                n
                =
                
                  
                    945
                    ⁢
                    
                      
                    
                    ⁢
                    
                      n
                      1
                    
                  
                  +
                  
                    2836
                    ⁢
                    
                      
                    
                    ⁢
                    
                      
                        n
                        ~
                      
                      2
                    
                    ⁢
                    
                      
                    
                    ⁢
                    mod
                    ⁢
                    
                      
                    
                    ⁢
                    3780
                  
                
              
            
            
              
                
                  n
                  1
                
                ,
                
                  
                    k
                    1
                  
                  =
                  0
                
                ,
                1
                ,
                2
                ,
                3
              
            
          
          
            
              
                k
                =
                
                  
                    945
                    ⁢
                    
                      
                    
                    ⁢
                    
                      k
                      1
                    
                  
                  +
                  
                    4
                    ⁢
                    
                      
                    
                    ⁢
                    
                      
                        k
                        ~
                      
                      2
                    
                    ⁢
                    
                      
                    
                    ⁢
                    mod
                    ⁢
                    
                      
                    
                    ⁢
                    3780
                  
                
              
            
            
              
                
                  
                    n
                    ~
                  
                  2
                
                ,
                
                  
                    
                      k
                      ~
                    
                    2
                  
                  =
                  0
                
                ,
                ...
                ⁢
                
                  
                
                ,
                944
              
            
          
        
      
    
    
      
        (
        6
        )
      
    
  




It maps the index n to the vector (n1,ñ2) from [0, 3779] to [0, 3]×[0, 944] as shown in Table I







TABLE I







THE INDEX MAPPING FOR THE FIRST STAGE












n1 = 0
n1 = 1
n1 = 2
n1 = 3

















ñ2 = 0
x[0]
x[945]
x[1890]
x[2835]



ñ2 = 1
x[2836]
x[1]
x[946]
x[1891]



ñ2 = 2
x[1892]
x[2837]
x[2]
x[947]



. . .
. . .
. . .
. . .
. . .



ñ2 = 944
x[944]
x[1889]
x[2834]
x[3779]










The data in each row of Table I are the input data of each 4-point FFT The input order is decided by the index n1. For example, for the row ñ2=1, the input order is (n1, ñ2 )=(0,1), (1,1), (2,1) and (3,1). They correspond to the data x[2836], x[1], x[946] and x[1891] respectively as shown in Table I.
Since the input data of each 4-point FFT has the same index ñ2, memory conflict could be avoided in the first stage by distributing the data into different memory banks by Eq. (7).

bank=n1+×mod7   (7)

After the first stage, the original data has been divided into 4 independent groups for four 945-point FFT and correspond to k1=0, 1, 2 and 3 respectively.
Similarly, for the 945-point FFT, we could also decompose it in the order 945=3×3×3×5×7 and map the index ñ2 to the vector (n2, n3, n4, n5, n6) from [0, 944] to [0, 2]×[0, 2]×[0, 2]×[0, 4]×[0, 6]. By combining all the decomposition equations for each stage, the full index mapping equations for the 3780-point FFT in this decomposition order are shown in Eqs. (8) and (9). The bank selection Eq. (10) is taken for memory conflict-free. And, the addressing equation could be taken as Eq. (11).

n=945n1+1260n2+2940n3+980n4+1512n5+540n6 mod3780   (8)

k=945k1+2380k2+3360k3+2520k4+2268k5+540k6 mod3780   (9)

bank=n1+n2+n3+n4+n5+n6 mod7   (10)

address=135n1+45n2+15n3+5n4+n5   (11)

After the first FFT symbol, the odd FFT symbol, has been computed, all the indexes ni would be transformed to ki in Eqs. (10) and (11). For the second input FFT symbol, the even FFT symbol, since the even FFT input data xeven[n] should be put in the location of the odd FFT output data xodd[k] with k=n, its mapping index, memory bank and address should be determined by Eqs. (9), (10) and (11) respectively.
Now, the present invention considers how to keep memory conflict-free under this data distribution for the even FFT symbol.
For the computation of the even FFT symbol, the present invention takes the reverse decomposition order of the odd FFT symbol, 3780=7×5×3×3×3×4. That is, the present invention computes it in the order 7-point, 5-point, 3-point, 3-point, 3-point and 4-point FFT. By the similar approach, the present invention could get the full input and output index mapping Eqs. (12) and (13) for the even FFT symbols just like Eqs. (8) and (9) for the odd FFT symbols. They map the input index n and output index k to the vector (a1, a2, a3, a4, a5, a6) and (b1, b2, b3, b4, b5, b6) respectively from [0, 3779] to [0, 6]×[0, 4]×[0, 2]×[0, 2]×[0, 2]×[0, 3] for the even FFT symbols.

n=540a1+2268a2+2520a3+3360a4+2380a5+945a6 mod3780   (12)

k=540b1+1512b2+980b3+2940b4+1260b5+945b6 mod3780   (13)

Comparing the input and output index mapping equation pair (9) with (12) and (8) with (13), the present invention finds that these two equation pairs could match perfectly with the relation, vector reverse, as shown in Eqs. (14) and (15).

(a1, a2, a3, a4, a5, a6)=(k6, k5, k4, k3, k2, k1)   (14)

(n1, n2, n3, n4, n5, n6)=(b6, b5, b4, b3, b2, b1)   (15)

Since the input data of the even FFT symbol xeven[n] should be put in the location of the odd computed FFT symbol output data Xodd[k] with k=n. Then, the present invention gets Eqs. (16) and (17) for bank selection and memory addressing for the even FFT symbol.

bank=a1+a2+a3+a4+a5+a6 mod7   (16)

address=135a6+45a5+15a4+5a3+a2   (17)

Note the input mapping equation (12) and the output mapping equation (9) are the same. And, the bank selection equations (10) and (16) also keep the same. Thus the memory access would keep conflict-free for the even FFT symbol by computing it with the reverse decomposition order of the odd FFT symbol.
Furthermore, the present invention notes that the output mapping equation (13) and the input mapping equation (8) are also the same. This means that, when the third FFT input data xthird[n] is put in the location of the even FFT output data Xeven[k] with k=n, the distribution of the third FFT input data would be the same with that being determined by Eqs. (8), (10) and (11). It returns to the state of the odd FFT symbol and we have xthird[n]=xodd[n].
From above discussion, a conflict-free variable radix FFT processor could be designed by reversing the decomposition order of the previous FFT symbol. It could support the in-place policy for both butterflies output and I/O data simultaneously.
FIG. 1 shows the memory-based 3780-point DFT processor design block diagram. The MEM_1 and MEM_2 are two memory blocks, each block contains 7 memory banks and each bank has 540 words. The FFT_CORE contains the processing element which could process the smaller sized DFT individually. The control unit controls the data access and processing element computation. The following, the present invention describes how the DFT processor work. For convenience, the present invention denotes the decomposition and computation order as type I order: 4-point, 3-point, 3-point, 3-point, 5-point and then 7-point DFT. And, the present invention denotes the reverse order of type I as type II order: 7-point, 5-point, 3-point, 3-point, 3-point and then 4-point DFT.
Suppose the 1st and the 2nd DFT symbols are stored in the memory blocks MEM_1 and MEM_2 respectively. And suppose the decomposition and computation order of the 1st and the 2nd DFT symbol are both in the type I order. Then, from the previous discussion, the present invention has:
(1) the 1st, 5th, 6th, 13th, . . . DFT symbols are stored in MEM_1 and computed in type I order.
(2) the 2nd, 6th, 10th, 14th, . . . DFT symbols are stored in MEM_2 and computed in type I order. (3) the 3rd, 7th, 11th, 15th, . . . DFT symbols are stored in MEM_1 and computed in type II order. (4) the 4th, 8th, 12th, 16th, . . . DFT symbols are stored in MEM_2 and computed in type II order.
For convenience, for the hardware implementation to get the index vector for data access, the present invention only shows the implement for the DFT size N=N1N2N3 in FIG. 2. As shown in FIG. 2, it is consists of several accumulators A1, A2, . . . , A5. The parameters U1, U2, U3, U4, q and r are determined by the decomposition equation (1) for each stage.
Table II is the comparison of this invention between different approaches for the real-time application for the memory-based DFT processor design. For [B4], it needs 4N words memory size and is two times of the others. This is because it doesn't adopt the in-place policy for butterflies computation and I/O data. Hence, in order to minimize the necessary memory size, the in-place policy should be adopted for both butterflies computation and I/O data. Exclusive of [B4], all of the others, only this invention and [A1] can support the mixed of any general radix and then for any size FFT. However, [A1] could not support the multi-bank memory structure without memory conflict to reduce the necessary clock rate for real-time application.
In this invention, the inventors propose the approach for memory based FFT processor design such that it could support the following three items simultaneously: (1) the in-place policy for both butterflies computation and I/O data (2) the mixed of any radix (3) the multi-bank memory structure.







TABLE II







THE COMPARISON BETWEEN DIFFERENT APPROACH













[A1]
[A2] [B2] [A5]
[A3]
[A4] B[3]
This invention
















Radix
All general
Fixed radix-r
Fixed radix-r
Radix-2/4
All general


In-place
Yes
Yes
Yes
Yes
Yes


Memory
2N words
2N words
2N words
2N words
2N words


Multi-bank
No
Yes
No
Yes
Yes









When this invention apply the proposed for the 3780-point DFT in Chinese DTV application, this invention could use only 2N words memory to achieve the system requirement, continuous data flow and in order I/O data. However, in order to achieve this, the solution [A6]-[A8] needs at least 3N words, [A9], [A11] needs at least 5N wo [A10] needs 6N words, and [B1] needs more than 3N words. Hence, for this application, if the 3780-point DFT processor is designed with this invention, the chip area could be reduced significantly than the processor which is designed with any current solution.
Although a preferred embodiment of the invention has been described for purposes of illustration, it is understood that various changes and modifications to the described embodiment can be carried out without departing from the scope of the invention as disclosed in the appended claims.

## Claims

1. A memory-based FFT/IFFT processor comprises:
a main memory to store data;
a processing element for decomposed FFT computation;
a control unit to control: (1) the memory for I/O data and to control butterflies computation (2) computation order of the decomposed FFT (3) the memory addressing of the main memory for data access with in-place policy, wherein the function (3) of the control unit controls the data access with in-place policy for both the butterflies computation and the I/O data for each memory blocks; and
wherein the address of accessed data is determined by the index vector (n1, n2. . . , nk) and equation (a2):





  
    
      
        address
        =
        
          
            
              ∑
              
                i
                =
                1
              
              
                k
                -
                2
              
            
            ⁢
            
              
                (
                
                  
                    ∏
                    
                      j
                      =
                      
                        i
                        +
                        1
                      
                    
                    
                      k
                      -
                      1
                    
                  
                  ⁢
                  
                    
                  
                  ⁢
                  
                    U
                    j
                  
                
                )
              
              ⁢
              
                u
                i
              
            
          
          +
          
            
              u
              
                k
                -
                1
              
            
            ⁢
            
              
            
            ⁢
            
              mod
              (
              
                N
                ⁢
                
                  /
                
                ⁢
                M
              
              )
            
          
        
      
    
    
      
        (
        
          a
          2
        
        )
      
    
  



Here, N=N1N2 . . . Nk and we take M=Nt is one of {N1, N2, . . . , Nk}. And, (U1, U2, . . . , Uk−1)=(N1, N2, Nt−1, Nt+1, . . . , Nk), (u1, u2, . . . , uk−1)=(n1, n2, . . . , nt−1, nt+1, . . . , nk).

2. The memory-based FFT/IFFT processor as claimed in claim 1, wherein the main memory has two memory blocks MEM block1 and MEM block2, when MEM block1 is used for FFT computation, then, MEM block2 would be used for I/O data, and vice versa.

3. The memory-based FFT/IFFT processor as claimed in claim 2, wherein each of the memory blocks consists of M memory banks and the size of each bank is N/M; Wherein, N is the FFT size and M is the bank number which is determined by designer.

4. The memory-based FFT/IFFT processor as claimed in claim 1, wherein the processing element is designed such that it can compute the decomposed FFT individually.

5. The memory-based FFT/IFFT processor as claimed in claim 1, wherein the main memory has two memory blocks MEM block1 and MEM block2, when MEM block1 is used for FFT computation, then, MEM block2 would be used for I/O data, and vice versa and wherein the function (1) of the control unit controls the memory blocks to exchange their function for FFT computation or for I/O data.

6. The memory-based FFT/IFFT processor as claimed in claim 1, wherein the function (2) of the control unit controls the processing element to compute the FFT symbol with the decomposed FFT in the reverse decomposition order of the previous FFT symbol for the same memory block; that is, for each memory block, if the FFT symbol in one memory block is computed in the order N1-point FFT, N2-point FFT, . . . , and then Nk-point FFT, the computation order of the next FFT symbol, which is stored in this memory block, would be Nk-point FFT, N(k−1)-point FFT, . . . , and then N1-point FFT.

7. The memory-based FFT/IFFT processor as claimed in claim 1, wherein the function (2) of the control unit controls the processing element to compute the FFT symbol with decomposed FFT in the reverse decomposition order of the previous FFT symbol for the same memory block; that is, for each memory block, if the FFT symbol in one memory block is computed in the order N1-point FFT, N2-point FFT, . . . , and then Nk-point FFT, the computation order of the next FFT symbol, which is stored in this memory block, would be Nk-point FFT, N(k−1)-point FFT, . . . , and then N1-point FFT and wherein the accessed data would appear in which memory bank is determined by the index vector (n1, n2, . . . , nk) and the equation (a1), where, c in Eq. (a1) is a constant integer, the index vector is corresponding to each decomposed FFT, N1-point FFT, N2-point FFT, . . . , and Nk-point FFT;


bank=n1+n2+ . . . +nk+c mod M  (a1).

8. The memory-based FFT/IFFT processor as claimed in claim 7 wherein the index vector was generated by the decompose equations (a3) and (a4) in each stage with N=N1N2. The input and output index are transformed by the input and output equations (a3) and (a4) respectively;


n=N2n1+A2n2 mod N n1, k1=0, 1, . . . , N1−1  (a3)



k=B1k1+N1k2 mod N n2, k2=0, 1, . . . , N2−1  (a4).

9. The memory-based FFT/IFFT processor as claimed in claim 1, wherein the index vector was generated by the decompose equations (a3) and (a4) in each stage with N=N1N2. The input and output index are transformed by the input and output equations (a3) and (a4) respectively;


n=N2n1+A2n2 mod N n1, k1=0, 1, . . . , N1−1  (a3)



k=B1k1+N1k2 mod N n2, k2=0, 1, . . . , N2−1  (a4).