Parallel Process Address Generator and Method

This invention relates in general to digital signal processing and in particular to parallel memory address generation in such applications.

High speed digital signal processing (DSP) in communication system applications require low power implementations of high performance DSP capabilities, especially for hand-held devices. These DSP's must be capable of efficiently performing the spectral analysis and digital filtering required for hand-held spread spectrum communication equipment, high speed modems and all digital radios. These applications require matrix math operations, complex arithmetic operations, Fast Fourier Transform (FFT) calculations, encoding/decoding, searching and sorting. Optimization of the computations require that the address generation mechanisms within the DSP provide the appropriate data sequence to the DSP arithmetic engine at a rate commensurate with the calculation rate. For example, for execution of the complex multiply operation:

four real multiplications and two real additions are required.

A Complex Arithmetic Processor (CAP) Very Large Scale Integration (VLSI) has been designed to execute a Radix-8 FFT at a throughput rate of one butterfly per 8 instruction cycles. A Radix 8 FFT requires seven complex multiplications, four real multiplications, 24 complex additions, 16 complex memory fetches and 8 complex memory stores per butterfly. What is needed are independent, sophisticated parallel memory address generation processors to control the associated memory fetches and stores.

Typical address generation techniques include using a separate processor from the arithmetic processor for address generation to reduce overall processing time. The address generation processor is typically configurable into one of several addressing modes. The addressing modes determine how the address sequence is to be calculated. Registers used as pointers, offsets, indices or special modifiers (such as modulo or bit reverse) in the address calculations are loaded sequentially. Multiple Sine and Cosine tables used in communication signal processing applications are typically stored in memory to avoid the step size calculation required in a single table.

Typical address generation techniques are not capable of providing the complicated address sequences required for all digital communications applications such as the CAP VLSI, however. The typical address generation techniques do not include the capability to perform multi-level indirect addressing in a single instruction cycle. This capability is required for fast table look-up functions in the Complex Arithmetic Processor.

Typical address generation techniques are also inadequate for calculating the address sequence for a radix 8 FFT fast enough to support the recurring single cycle complex multiplies required for the computation in the Complex Arithmetic Processor. These techniques do not provide for the simultaneous calculation of offset addresses into the compact Sine and Cosine tables. Address register initialization using typical address generation techniques does not allow the parallel loading of predetermined configurations required for minimum overhead radix 8 address generation.

Accordingly, it is an advantage of the present invention to provide a new and improved method and apparatus for multiple, independent address generation for a minimum of four input data streams and two output data streams in a CAP VLSI. It is a further advantage of the method and apparatus that the subsequent addresses (or address sequence) for each data stream can be calculated within the address generator with sufficient speed (a computational throughput of one complex multiply per instruction) to provide a set of addresses each instruction cycle of the DSP. It is still a further advantage that the method and apparatus allow for low power DSP implementations integrating address generation with memories and an arithmetic engine on a single VLSI device.

To achieve these advantages, a memory linked address generator for a complex arithmetic processor executing an algorithm sequence is contemplated which includes memories, a clock for generating a clock cycle, and a decoder for determining position of the complex arithmetic processor within the algorithm sequence. The decoder is coupled to the clock and address pointer generators are coupled to the decoder and to the memories. The address pointer generators generate address pointers within the clock cycle for at least some of the memories in response to the position of the complex arithmetic processor within the algorithm sequence.

To further achieve these advantages, a method for generating address pointers for memories in a complex arithmetic processor is contemplated which includes the step of determining, by the complex arithmetic processor, position within an algorithm sequence. Based on the position, the complex arithmetic processor determines address pointers for each of at least some of the memories within one clock cycle.

The above and other features and advantages of the present invention will be better understood from the following detailed description taken in conjunction with the accompanying drawings.

In the single FIGURE, there is shown a schematic of a parallel address generator method and apparatus in accordance with a preferred embodiment of the invention.

Generally, the present invention provides a method and apparatus for generating multiple address pointers within a given clock cycle. This may be accomplished by first determining the position within an executing algorithm, and based on this position, update the address pointers with the correct values. The updated address pointers are either calculated based on previous values or are fixed numbers that are simultaneously loaded into the pointer locations. The data already stored in memory that is accessed by the pointers can then be used as operands for arithmetic functions, or can be used to update address pointers to other memory locations. Address pointers are also used to store results in output memory. Some algorithms require bit reversed addresses to retrieve data from memory. This is accomplished by first retrieving an address pointer and bit reversing this pointer. Based upon the number of bits needed for the memory address, the address pointer is then scaled the appropriate amount to obtain the desired address. The decision to bit reverse comes from the algorithm sequence determiner.

The present invention can be more fully understood with reference to the FIGURE. The FIGURE illustrates a complex arithmetic processor 1, including a memory linked address generator 10 having a clock 11, which generates a predetermined number of clock cycles. The clock 11 is coupled to and provides the clock cycles to an algorithm sequence determiner 12, which determines the position within an algorithm sequence. Based upon this position, the address pointer generators (APG) 13-17 are updated accordingly. These address pointer generators point to their corresponding memories 18-22 which store or retrieve the relevant data needed to complete the algorithm sequence. These memories can also contain values that are used to update the address pointer generators directly in hardware. Hence, the name memory linked address generators. Although the FIGURE shows only four APGs 13-17, four memories 18-22, and five registers 24-29 inside the address pointer generator 17, the invention is scalable.

Address pointer generators 13-17 include a pointer calculator 23, which calculates pointers stored in registers 24-29. If instructed by the algorithm sequence determiner, the pointer calculator can update all the pointers stored in the registers 24-29 in one clock cycle. Any one of the pointers stored in these registers can be used to address memory and to update itself using the pointer calculator. If bit reversed addressing is required, the output of any given register can be bit reversed using the bit reverse address calculator 31. The pointer enters the bit reverse address calculator and is first bit reversed using the bit reverse block 32. Then, based upon the number of bits needed for the memory address, the bit reversed number is scaled the appropriate amount using the scaler 33. The result is a bit reversed address which is used to store or retrieve the desired data in memory. In either the normal or bit reversed addressing mode, the address is stored in address output register 36 to be used on the following clock cycle to address memory.

Memory link address generator 10 provides multiple address pointers for memories 18-22 within a single clock cycle. A new instruction is fetched every clock cycle so that new memory locations can be accessed every clock cycle. There is a three stage pipeline delay from the instruction fetch to a memory access. In stage one the instruction is fetched and the instruction fields are latched into the appropriate decode registers in the algorithm sequence determiner 12. In stage two the new address pointer is calculated and latched into the address output register 36 and any of the address pointer registers 24-29. In stage three the address in output register 36 is used to access memory.

The algorithm sequence determiner 12 fetches an instruction which it partitions into the number of fields required to individually control each memory 18-22. The bit fields are latched into decode registers assigned to a particular memory. The output of the decode register for memory 22 is locally decoded at the APG 17 connected to that memory. The pointer calculator 23 receives the bit field from the algorithm sequence determiner 12 and performs the calculation according to the number that is in the bit field. Since each APG is assigned it's own bit field from the instruction, multiple address pointer generators are programmed simultaneously within one clock cycle. Calculations performed by the pointer calculator 23 include the operations listed below.

1. No registers updated.

2. Load one register with data from the instruction.

3. Load all registers with data stored in hardware.

4. Load all registers with data based on the sum of a pair of registers.

5. Load a register with the sum of data stored in that register and a number stored in hardware. Output the result on the current clock cycle.

6. Load a register with the sum of data stored in that register and a number stored in another register. Output the result on the current clock cycle.

7. Load a register with the sum of data stored in another registers and the contents of another memory. Output the result on the current clock cycle.

8. Load a register with the sum of data stored in two other registers.

9. Output the contents of a pointer register.

10. Output the contents of a pointer register and then update it with the sum of data stored in that register and a number stored in hardware.

11. Output the contents of a pointer register and then update it with the sum of data stored in that register and a number stored in another register.

12. Output the contents of a pointer register and then update it with the sum of data stored in that register and the contents of another memory.

13. Output the contents of a pointer register bit reversed according to the maximum size of the pointer. Operations 5-7 and 9-12 can be performed in conjunction with the bit reversal operation.

There are many applications for algorithms with multiple pointers. Filtering requires a moving base pointer about which other address pointers are calculated. Matrix applications require row and column pointers. The Fast Fourier Transform (FFT) uses multiple pointers to access unit vectors that rotate complex data samples. A Radix 8 FFT uses sets of seven different unit vectors which have angles that are multiples of a base angle. This invention allows a pointer to a new base angle and six multiples of the base angle to be computed in one clock cycle. Computing efficiency is gained when all of the pointers can be initialized in one instruction. For example, a Radix 8 Butterfly calculation requires 26 pointers in order to execute the butterfly in eight instructions. During certain portions of the calculation up to 18 pointers need to be updated in one instruction. In particular, a critical area is in accessing unit vectors which reside in a complex memory space. The complex memory space consists of two memories. One is loaded with a SIN table, the other a COS table. In each Radix 8 butterfly, a new unit vector is accessed every instruction for seven instructions. On the eighth instruction, the seven new unit vector pointers may be computed. If the base pointer is N, the unit vector pointer set for radix 8 consists of N, 2N, 3N, 4N, 5N, 6N and 7N. The following table shows the contents of the pointer registers if the base angle is 5.625 degrees and the memories contains 1024 point SIN and COS tables.

During a new unit vector update, the following calculations take place in both memory address pointer calculators. Five adders are required in each pointer calculator.

R1+16>R1 add

(R1 +16)*2>R2 wired shift

(R1+16)*2+(R1+16)>R3 wired shift, add

(R1+16)*4>R4 wired shift

(R1+16)*4+(R1+16)>R5 wired shift, add

(R1+16)*4+(R1+16)*2>R6 wired shifts, add

(R1+16)*4+(R1+16)*2+(R1+16)>R7 result to R6, add

In addition to the special case of unit vector updates, the pointer registers can be initialized in one clock cycle to fixed values which are common to most algorithms. The most common would be the base address of RAM or ROM blocks which would be the starting point of data. In pipelined systems the output pointers lag the input pointers by the pipeline delay. In order to contain all of the calculations within a loop it may be necessary to initialize the output pointers to a location before the actual starting point.

In some applications such as data compression, data correction, cryptography, and matrix math, it is difficult to compute the next address quickly because the addressing sequence is non-linear or even random. In some of these cases addresses can be created by sequencing through a table of pointers. This is commonly called a linked list. In the case of encryption, the sequence through the table of pointers is random. Random data may come from an external device called a key generator. This invention creates the required linkage, in hardware, by allowing data from a memory to directly drive the address pointer generator of another memory. These computations are defined as operations 7 and 12 in the above list. Normally data would have to be fetched and stored to a general purpose register in one instruction, transferred to an address generator register in the next instruction and then used to generate a new address in the last instruction. This invention has a direct data path from memory to the address generator input allowing a new address to be generated each instruction based on data from another memory.

While performing an FFT algorithm an array of input data is sorted into a different output sequence. The data can be put back in the correct order if bit reversed addressing is used. The FFT can be performed with the inputs reversed and the outputs in order, or the inputs in order and the outputs reversed. Examples of bit reversing are shown below.

The main computational consideration for doing bit reversing is the address range of the data that is being reversed. An array of 1024 points requires 10 bits to be reversed while an array of 64 points requires 6 bits to be reversed. Because most applications only require a linear sequence of bit reversed addresses, they are created by adding the Most Significant Bit (MSB) of the required range to the last generated address and performing a reverse carry. This only works if the last address is a bit reversed address and the required output is the next one in the sequence.

This invention allows a bit reversed address to be output from a pointer without modifying the pointer. It can produce the bit reversed result of Address+N, where N is any integer. It is not restricted to Previous Address+1. This feature is useful in large pipelined arithmetic engines where the data may need to be fetched out of sequence to balance the computational load. Bit reversal is implemented by providing a data path which physically reverses all of the address bits available by means of circuit tracks. If a smaller address range is required the data is shifted to the right.

Thus, a parallel processor address generator and method has been described which overcomes specific problems and accomplishes certain advantages relative to prior art methods and mechanisms. The present invention provides a method and apparatus for generating multiple address pointers within a given clock cycle. The address generation device and method support multiple, independent address generation for a minimum of four input data streams and two output data streams. The subsequent addresses (or address sequence) for each data stream can be calculated within the address generator with sufficient speed to provide a set of addresses each instruction cycle of the DSP. Low power implementations can be realized, with address generation integrated with memories and an arithmetic engine on a single VLSI device.

Thus, there has also been provided, in accordance with an embodiment of the invention, a parallel processor address generator and method that fully satisfies the aims and advantages set forth above. While the invention has been described in conjunction with a specific embodiment, many alternatives, modifications, and variations will be apparent to those of ordinary skill in the art in light of the foregoing description. Accordingly, the invention is intended to embrace all such alternatives, modifications, and variations as fall within the spirit and broad scope of the appended claims.