WO2001050606A1

WO2001050606A1 - Carry lookahead for programmable logic array

Info

Publication number: WO2001050606A1
Application number: PCT/US2000/035255
Authority: WO
Inventors: Charle' R. Rupp
Original assignee: Adaptive Silicon, Inc.
Priority date: 1999-12-30
Filing date: 2000-12-22
Publication date: 2001-07-12
Also published as: TW480818B; AU3266401A; US6426648B1

Abstract

Carry lookahead techniques are adapted for implementation in a programmable logic device. In one example of the invention, a carry result is computed for a block of function cells, each function cell representing one bit in a multibit operation that uses carry. This carry result is combined with the carry input from a function cell block representing less significant bits in the operation and a carry output is provided to a function cell block representing more significant bits in the operation. The received carry can also be supplied to adjust provisional carry results for each bit associated with the function cells in the block. Accordingly, the received carry input need not be rippled through all the function cells in the block, thus reducing carry propagation delays. This technique is suitable for use in programmable logic devices because only minimal additional logic need be included in each block of function cells (such as the CLBs and LABs in the prior art), and because few, if any, new interconnections between blocks need be introduced.

Description

CARRY LOOKAHEAD FOR PROGRAMMABLE LOGIC ARRAY Background of the Invention

1. Field of the Invention

The present invention relates to programmable logic arrays, and in particular, to structures and techniques for improving carry propagation programmable logic arrays.

2. Descnption of the Related Art

Techniques for implementing carry propagation in commercially prevalent programmable logic devices (PLDs) or arrays (PLAs) aim at fast carry propagation. FIG. 1 illustrates a configurable logic block (CLB) of a conventional PLD or PLA made by Xilinx, Inc. This CLB is described in more detail in U.S. Patent No. 5,546,018. As shown, the Xilinx CLB includes four four-mput function generators F, G, H, J each comprising lookup tables for implementing one bit of an aπthmetic function of two variables which are received on the input terminals 0, 1, 2, 3 of each function generator. Associated with each function generator is a fast carry mux Cl, C2, C3, C4. The purpose of these muxes is to propagate carry based on the logical mput CIN and the result of the aπthmetic function between input vaπables A and B so as to provide a cumulative carry output signal COUT.

In the conventional PLD descπbed above, for multibit operations of two vaπables greater than four bits, the carry output signal of one CLB is provided to the carry input of a higher-order CLB in a chain of CLBs depending on the number of bits desired. It should be noted that in the CLB illustrated in FIG. 1, a sum output stage is provided in another CLB for finalizing the sum values using the outputs of the CLB in FIG. 1.

FIG. 2 illustrates a logic array block (LAB) of a conventional PLD made by Altera, Inc. This LAB is described in more detail in U.S. Patent No. 5,761,099. In this device, each logic element 12 (typically eight or ten per LAB) can be configured to perform one bit of an aπthmetic operation of two input variables. Each logic element 12 further includes logic 13 for providing a carry output signal based on a carry input and the aπthmetic operation of two vaπables. As shown m FIG. 2, carry is propagated between logic elements along lines 70a m πpple fashion as in the Xilmx device. Lines 70b provide for multibit operations of two variables greater than the number of bits capable of being processed by a single LAB. In such circumstances, the "direct carry out" signal of one LAB is provided to the "direct carry in" signal of a higher-order LAB m a chain of LABs depending on the number of bits desired.

The conventional πpple carry propagation technique described above is slow because the highest order output is not valid until a carry has rippled through all the lower order bits. -2-

Carry lookahead techniques offer the promise of much faster carry propagation than can be achieved with πpple carry techniques. Such techniques have been implemented in digital arithmetic structures for decades (e g. the 74182 look-ahead carry generator). See, for example, Joseph D. Greenfield, Practical Digital Design Using ICs, § 14.11 (1983). Some theoretical discussions have addressed considerations for extending such techniques to programmable gate arrays See, for example, Charle' R. Rupp, "Fast Algorithms for Regular Functions in Field Programmable Gate Arrays," Proceedings of the Third Annual PLD Conference (1993). However, prior art structures for performing carry lookahead features require a prohibitive number of elements and complex interconnections therebetween that are not suitable for implementation in a PLD or PLA. Accordmgly, carry lookahead techniques have not been seriously considered for use in conventional programmable logic devices.

What is needed in the art, therefore, is an improved carry propagation technique that is suitable for implementation m a programmable logic device. The present invention fulfills this need, among others. Summary of the Invention

Accordingly, it is an object of the present invention to overcome the above-described problems in the prior art.

Another object of the invention is to improve the speed of operations in a programmable logic device. Another object of the invention is to improve the speed of operations that require carry propagation in a programmable logic device.

Another object of the invention is to provide improved performance in aprogrammable logic device with minimal additional structure.

Another object of the invention is to minimize the number of interconnections required to implement carry propagation techniques m a programmable logic device.

Another object of the invention is to provide a carry lookahead technique that is suitable for implementation in a programmable logic device.

These and other objects are fulfilled by the present invention, in which carry lookahead techniques are adapted for use m a programmable logic device. In one example of the invention, a carry result is computed for a block of function cells, each function cell representing one bit in a multibit operation that uses carry. This carry result is combined with the carry input from a function cell block representing less significant bits in the operation and a carry output is provided to a function cell block representing more significant bits in the operation. The received carry can also be supplied to adjust provisional carry results for each bit associated with the function cells in the block. Accordingly, the received carry input need not be rippled through all the function cells in the block, thus reducing carry propagation delays. This technique is suitable for use in programmable logic devices because only minimal additional logic need be included in each block of function cells (such as the CLBs and LABs in the prior art), and because few, in any, new interconnections between blocks need be introduced.

Brief Description of the Drawings

These and other objects and advantages of the present invention will become apparent to those skilled in the art after considering the following detailed specification, together with the accompanying drawings, wherein: FIG. 1 illustrates the carry technique used in a CLB in a conventional programmable logic device made by Xilinx, Inc.;

FIG. 2 illustrates the carry technique used in a LAB in a conventional programmable logic device made by Altera, Inc.;

FIG, 3A is a block diagram illustrating an arithmetic logic unit (ALU) in accordance with the present invention;

FIG. 3B is a logic symbol of a function cell such as that included in the ALU of FIG. 3 A;

FIG. 4 illustrates an ALU in accordance with an example of the invention implementing a ripple carry scheme;

FIG. 5 illustrates a K block such as that can be used to implement the carry equations of the present invention;

FIG. 6 illustrates an ALU in accordance with another example of the present invention implementing a minimum delay balanced tree carry scheme;

FIG. 7 illustrates a PK block such as that can be used to implement the carry equations of the present invention; FIG. 8 illustrates an ALU in accordance with another example of the present invention implementing a pyramid carry scheme;

FIGs. 9A and 9B illustrate a CLA block that results from a decomposition of part of the structure in FIG. 8;

FIGs. 10A and 10B illustrate a CLU block that results from a decomposition of remaining parts of the structure in FIG. 8;

FIG. 11 illustrates how the blocks identified in FIGs. 9 and 10 can be interconnected to implement the ALU illustrated in FIG. 8;

FIG. 12 illustrates an ALU in accordance with a preferred example of the present invention implementing a carry lookahead scheme that is readily adaptable to programmable logic devices; FIG 13 illustrates how a CLB in a conventional programmable logic device can be modified to implement the carry lookahead scheme of the present invention;

FIG. 14 illustrates a function cell such as that disclosed in co-pendmg U.S. Patent Appln. No 09/475,400 that is modified to implement the carry lookahead scheme of the present invention; and FIG 15 illustrates an arithmetic mode controller such as that disclosed in co-pendmg U.S

Patent Appln. No. 09/475,400 that is modified to implement the carry lookahead scheme of the present invention.

Detailed Description of the Preferred Embodiments

Although the following discussion will focus on multi-bit addition operations, those of skill in the art will understand that the discussion can be easily extended to apply to subtractors, mcremen- ters, decrementers, counters, and accumulators, in addition to other operations that use carry logic.

In aπthmetic logic, it is recognized that the sum Y of two single-bit inputs A and B can be expressed by the logical operation:

Y = A (XOR) B (Eq. 1) The present invention builds upon carry lookahead theory m which it is recognized that the carry output bit C_out of an arithmetic operation between single-bit inputs A and B and a single-bit carry input C_m can be expressed as:

Cout = (A (AND) B) OR (Cm (AND) (A (XOR) B)) (Eq. 2) From this equation, a smgle-bit propagate (P) and generate (G) signal are defined m the conventional manner as:

P = A (XOR) B (Eq. 3)

G = A (AND) B (Eq. 4)

Accordingly, Eq. 1 can be simplified as:

C_out = G (OR) (C,„ (AND) P) (Eq. 5) The above carry lookahead equations can be broken down and re-expressed m many useful ways. Of particular note with respect to the present invention, is that, for a particular bit j in a multibit operation between multibit input words A and B, the carry C, and sum Y, can be expressed m terms of same bit j and less-significant bit j-1 values of P and G as:

C_j = (C_j.i (AND) P_j_ι ) (OR) G,_ι (Eq. 6) and

Y_j = C_j (XOR) P_j (Eq. 7)

FIG. 3 A is a block diagram illustrating an example implementation of the present invention As shown in FIG. 3A, a multi-bit operator 300 in a programmable logic array includes a plurality of function cells 302-0 to 302-n, each configured to perform a single-bit operation based on data inputs A and B and function input F, a carry lookahead stage 304 that receives the propagate (P) and generate (G) outputs of each function cell 302, as well as a carry input value C_m, and provides preliminary sum outputs P' and G' corresponding to each function cell, as well as a carry output value Cout, and a sum output stage 306 that receives the P' and G' preliminary sum outputs corresponding to each function cell and generates final outputs Y based thereon.

For the purposes of the present invention, function cells 302 are preferably those described in U.S. Patent Appln. No 09/475,400, filed December 30, 1999, commonly owned by the assignee of the present invention. However, it should be noted that cells 302 can be conventional programmable elements in programmable logic arrays such as those made by Xilinx, Inc. and Altera, Inc. After being taught by the illustrative examples provided in the present specification, those of skill in the art will understand how such conventional cells and/or groups of such cells such as CLBs or LABs illustrated in FIGs 1 and 2, may need to be modified to provide appropπate P and G values as outputs or intermediate values rather than, or in addition to, their existing sum and carry outputs.

In the following figures, function cell 302 will be represented by the logic symbol shown in FIG. 3B. In general, function cell 302 performs a one-bit operation on received one-bit inputs A and B based on the received function input F, and provides output signals based on those inputs. In the example shown m the following figures, the outputs are propagate and generate signals, although this example is illustrative and not limiting.

Various examples of carry lookahead stage 304 and sum output stage 306 in accordance with the pπnciples of the invention will now be described. Although shown separately for illustration and for clarity of the invention, it will become apparent to those of skill in the art that practice, vaπous components of stages 304 and 306 may actually be included within or grouped with function cells 302, and vice versa. The actual collection and division of components between cells 302 and stages 304 and 306 is considered to be a design choice, although preferable examples will be illustrated below for a more complete understanding of different aspects of the present invention.

FIG. 4 illustrates a first example of a 16-bit ALU circuit 400 m accordance with the invention. As can be seen, in this example of structure 300, carry lookahead stage 304 implements a πpple carry technique wherein K blocks 402 implement Eq. 6 to derive the carry C_j for each bit j from the initial P,.j and G_j_ signals from the previous bit j-1 and the carry signal C_j_ι from bit j-1. As can be further seen, sum output stage 306 includes XOR gates 404 which respectively form the sum Y_j from the carry signal and propagate signal for each bit j in accordance with Eq. 7. The output of K block 402 for each bit is thus used both to provide the carry for the bit for use in deπvmg the sum for that bit, and for mput to deπving the carry for the next significant bit in πpple fashion. This is the least expensive implementation of structure 300 in terms of number of components required, but results in a worst case propagation time which is directly proportional to the number of bits of the operands. This can be seen in the figure by tracing a change in the value of A0 signal to the final carry output signal C_out. In this path, the change in the extreme case must traverse each of the sixteen K blocks. Although this carry chain structure suffers from the same carry propagation delays common m the prior art, it is relatively simple to implement in PLDs or PLAs with only minor modification of commercial FPGA products, and so is presented herein for illustration.

FIG. 5 illustrates an example of K block 402 that can be used in the structure 400. As shown m FIG. 5, K block 402 includes AND gate 502 forming the logical AND result of received propagate and carry signals, and OR gate 504 forming the logical OR result of the output of AND gate 502 and the received generate signal. As explained above, K block 402 can be readily adapted for use m implementing carry lookahead Eq. 6.

A "minimum delay balanced tree" structure 600 for implementing a 16-bit ALU in accordance with the invention is illustrated in FIG. 6. As can be seen, in this alternative implementation of structure 300, carry lookahead stage 304 includes thirteen K blocks 402 and twenty PK blocks 602 that are arranged and interconnected for simultaneously propagating carry and forming P and G outputs for sum output stage 304, which includes XOR gates 404 for each bit as in the previous example.

The carry lookahead stage 304 in structure 600 implements a "fan-out" technique whereby carry results from a k-th stage are fanned out to the carry determination blocks for the next 2^ significant bits. For example, as shown m FIG. 6, the carry result from the K block m stage 604-1 that determines carry for bit 1 is fed to the K block and PK block in stage 604-2 for determining the carry for bits 2 and 3. Likewise, the carry result from the PK block in stage 604-2 is fed to the three K blocks and one PK block in stage 604-3 that determine the carry for bits 4, 5, 6 and 7. This technique results from recalling from Eq. 6 that, in general:

C_j = (C_j_ι (AND) P_j_! ) (OR) G,_ι (Eq. 6)

Accordingly, it immediately follows that:

C_j-1 = (C_j.2 (AND) P_j_₂ ) (OR) G_j.₂ (Eq. 8) and by substitution of Eq. 8 back into Eq. 6: C_j = ((C_j.2 (AND) P_j_₂ ) (OR) G_j.₂ ) (AND) P_j_ι ) (OR) G,_ι (Eq. 9)

It should be apparent that this substitution process can be performed iteratively to determine carry for any bit j based on any known carry from a pπor bit j-x and all intervening x P and G values, that is: C_j = f(C_j._x, P_j-1 ... P_j-χ, G_j_ι ... G,.χ) (Eq. 10) It should be further apparent that logical combinations of input values A and B can be substituted for equivalent values of P and G and C m various ways to arrive at the same final carry value.

An important feature of Eqs. 9 and 10, and uniquely applied in the present invention, is that the carry for each intervening bit between C_j and Cι__x need not be expressly calculated before determining the desired carry value.

FIG. 7 illustrates an example of PK block 602 having an OR gate 702 forming the logical OR result of received propagate and carry/generate signals, AND gate 704 forming the logical AND result of the propagate signals from the current and previous stages, and AND gate 706 forming the logical AND result of the output of OR gate 702 and the received generate signal. As seen in FIG. 7, PK block 602, alone or cascaded with other PK blocks and/or K blocks 402 depending on the number of intervening propagate and generate values required, is useful for implementing Eqs. 9 and 10.

Although this type of structure achieves minimal carry propagation delay, the cost to implement it in terms of number of components required is prohibitive for most general purpose programmable logic arrays. Furthermore, the irregular nature of the interconnections deteπorates the performance and makes it difficult to define a regular pattern for tiling the programmable structure.

A variation of the balanced tree principle is called the "pyramid structure," a 16-bit ALU example implementation of which is illustrated in FIG. 8. As shown in FIG. 8, carry lookahead stage

304 of structure 800 includes fifteen PK blocks 602 and sixteen K blocks 402 that are arranged for simultaneously propagating carry and forming P and G outputs for sum output stage 304, which includes XOR gates 404 for each bit as m the previous examples.

This is a variation of the fan-out technique described above. However, rather than fanning out intermediate carry results as much as possible, only the intermediate carry result of one set of four bits is supplied to the next higher order set of four bits. Intermediate PK blocks are then used to collect propagate and generate signals from each set of four bits and supply them to the next set of four bits.

The worst case carry propagation delay of this circuit is about twice that of the previous case. Although highly irregular, this structure has a very useful decomposition property by noting that all of the blocks labeled 802 in the circuit are the same. Similarly, all of the blocks labeled 804 are the same. By combining each logic block of type 802 on the left with a corresponding logic block of type 804 on the πght, a simpler form is achieved that allows the construction of a more complex circuit. This simpler logic circuit 900 and its corresponding block diagram symbol are shown in FIGs. 9A and 9B.

The remaining circuitry of the ongmal 16-bit structure (the logic circuit box labeled 806 m the figure) is then collected and forms the Carry Lookahead Unit (CLU) 1000 as shown m FIG. 10 A, and its corresponding block diagram symbol is shown in FIG. 10B. FIG. 1 1 then shows the construction of 16-bit ALU 800 using these 4-bit blocks. This is essentially the same interconnection of signals used to construct a 16-bit ALU using the '74181 and '74182 circuits. Larger ALUs can then be constructed by forming larger trees using these building blocks. Although this form of carry propagation is popular in the design of computers due to its relatively low cost and significant performance improvement compared to the ripple structure, it is undesirable for the construction of a regular programmable logic array since the wiπng and placement of the K and PK blocks is highly irregular.

FIG. 12 illustrates yet another example implementation of a 16-bit ALU structure 1200 in accordance with the present invention. As shown m FIG. 12, carry lookahead stage 304 of structure 1200 includes twelve PK blocks 602 and sixteen K blocks 402 that are connected and arranged for simultaneously propagating carry and forming sum and carry precedent outputs for sum output stage 304, which includes XOR gates 404 for forming the sum output from the propagate and carry signals for each bit as m the previous examples. As in the immediately preceding example implementation of structure 300, due to the similarity of arrangement and interconnections, useful decomposition properties are apparent. For example, the 16-bit ALU structure can be broken up into identical 4-bit ALU blocks 1202, four identical increment adjustment blocks 1204, and an intermediate carry block 1206. In this example shown in FIG. 12, each ALU block 1202 and increment adjustment block processes four bits for illustration, but it should be noted that the pπnciples of the invention can be extended to other numbers of bits. For example, if each ALU block 1202 processed eight bits, the chain of PK blocks would be extended to a length of seven rather than three, the intermediate carry block 1206 would only include two K blocks, and each increment adjustment block 1204 would include seven K blocks rather than three. It should be apparent that a multiplexer could be provided between chains of K blocks and increment adjustment block 1204 to allow for dynamic selection between different ALU block sizes. It should be further apparent that each ALU block need not process the same number of bits.

As shown in FIG. 12, for each 4-bit ALU block 1202, cumulative propagate and generate signals are formed by a short ripple pattern using PK blocks 602. The outputs of the final PK block are fed to intermediate carry block 1206 and combined with the carry output from the previous 4-bit stage to form an intermediate carry out signal using a single K type logic block 402 (i.e. an intermediate carry calculator). The K block in intermediate carry block 1206 and the preceding three PK blocks thus implement a four-bit iteration of Eq. 9 to generate a true intermediate carry output for each four bits (i.e. C4, Cβ, Ci 2 and C_out). In addition to propagating them forward to the next K block in intermediate carry block 1206 for use in determining the next intermediate four-bit carry result, the K blocks in intermediate carry block 1206 distribute the true intermediate carry out signals to the increment adjustment block 1204 for use in determining the sum output associated with each bit m the next most significant block as will be explained below.

As shown m FIG. 12, for the least significant bit in increment adjustment block 1204, output Y can be simply determined from the XOR operation between the received carry input and the P output from the function cell 302 associated with that bit in ALU block 1202 in accordance with Eq. 7. For the next most significant bit, the associated K block receives the P and G outputs from the function cell 302 associated with the next least significant bit in ALU block 1202, and the received carry input, and computes the carry for that bit in accordance with Eq. 6 for logical XOR combination with the P signal for that bit in accordance with Eq. 7. For more significant bits, associated K blocks receive the carry input and outputs from associated PK blocks in ALU block 1202, and thus they together implement iterations of Eq. 9 to determine carry for XOR combination with the P signal for the bit. In essence, the carry for each bit is provisionally computed in ALU block 1202 based on an assumption that the mput carry is zero (because the output propagate and generate values from block 1202 are not a function of the carry input to the block), and this assumption is corrected in increment adjustment block 1204 for each bit based on the actual received carry.

It should be noted that, unlike the previous examples, the highly regular form of this carry chain circuit is very suitable to the construction of high speed programmable logic array devices.

For example, it is only necessary to add structure to compute and propagate the intermediate carries (as performed by K blocks in intermediate carry block 1206) to each CLB or LAB of the devices shown in FIGs. 1 and 2, respectively. Appropriate configuration switches that specify whether the CLB or LAB is the starting point for an ALU chain may also need to be added as well. It should be further noted that this carry propagation can yield dramatic improvements m computation speed. That is, rather than requiring the carry input for each CLB or LAB to πpple through each logic element m a chain of CLBs or LABs forming the multibit operator, a received carry input for the CLB or LAB can just be combined with the carry for that CLB or LAB and propagated to the next CLB or LAB in the chain. Moreover, the propagation of carry between CLBs or LABs can use existing interconnections.

FIG. 13 illustrates a CLB 1300 that has been modified in accordance with this example of the invention. As shown in FIG. 13, the carry mux Cl of the lowest order bit of CLB 1300 receives a zero input rather than the carry input of the previous CLB, and the resultant carry for the CLB is combined with the received carry input in intermediate carry determination block 1302. Carry determmation block 1302 includes logic for providing the true carry COUT based on the received carry input CIN and the resultant carry for the CLB This true carry is also provided to the sum output stage (typically an adjacent CLB) for use in determining the sum output for each bit, thus correcting the assumption that the received carry is zero if necessary. The actual logic included m carry determination block 1302 (and in the adjacent CLB or additional logic for implementing the sum output stage) is considered an implementation detail that becomes apparent to those skilled in the art after being taught by the present specification. Moreover, it should be apparent that further configuration switches may need to be added to implement this modified carry propagation scheme. However, the interconnections for propagating carry signals CIN and COUT between CLBs can remain unchanged.

Although the present invention is useful in conventionally available programmable logic devices, even further advantages are obtained when the inventive carry propagation techniques are implemented using the programmable logic array structures disclosed in U.S. Patent Application No. 09/475,400, filed December 30, 1999, commonly owned by the assignee of the present invention, the contents of which are incorporated herein by reference (hereinafter referred to "the MSA application").

In particular, FIG. 14 illustrates a function cell 1400 such as that illustrated in FIG. 9 of the MSA application that has been modified in accordance with the present invention. As shown in FIG. 14, in addition to the structure associated with function cell 302, cell 1400 includes elements of both ALU block 1202 and increment adjustment block 1204 associated with a single bit operation. In particular, logic 1402 (as does the K block in increment adjustment block 1204) computes the carry for the bit based on received carry signals and (perhaps) propagate and generate signals from a less significant bit. Likewise, logic 1404 implements the functionality associated with PK blocks m ALU block 1202 for providing a πpple combination of the local propagate and generate signals with (perhaps) propagate and generate signals from a less significant bit.

For implementing the additional K block that is needed to compute the intermediate carπes as in intermediate carry block 1206, FIG. 15 illustrates a modified arithmetic mode controller 1500 based on that illustrated m FIG. 20 of the MSA application that is included m an ALU controller for each ALU block, as descπbed in that application. In effect, the functionality of intermediate carry block 1206 is split between the ALU controllers for each ALU block of the MSA application. Aπthmetic mode controller 1500 can be used in conjunction with a plurality of function cells such as 1400 for implementing an ALU such as that illustrated in FIG. 12. The arrangement and interconnection of cells 1400 and controller 1500 will be understood with reference to the MSA application and the present specification. As shown in FIG. 15, logic 1506 effectively performs the function of a K block in intermediate carry block 1206. The signal K is the received carry from a less significant stage m the carry chain, which is combined with the P and G outputs received from the most significant function cell 1400. The KE signal output from multiplexer 1502 based on the computed carry and configuration bits set in configuration memory is passed onto the ALU controller of the next ALU block associated with the next most significant bits. The PE and GE signals are then used to correct provisional carries for computing the sum Y of each function cell 1400 for the bits associated with this ALU block and ALU controller.

FIG. 15 also illustrates how the number of bits per PK chain can be dynamically adjusted between four and eight bits, for example. In particular, multiplexer 1504 and signal KM can determine whether or not to continue a PK chain. If the chain is not continued, the number of bits is four, otherwise the number of bits is eight.

Table 1 summarizes the comparison of the different types of the carry chain structures for ALU chains having N-bit inputs. For each structure type, the "T" column indicates the number of time units of delay for the worst case traversal of the K and PK blocks of the structure (the total number of which are included m the structure being represented under the column labeled "PK"). As can be seen, the basic structure (herein referred to as "MSA") based on 4-bit ALU blocks is equivalent in cost and performance to a pyramid Carry Lookahead structure for word sizes up to 24- bits. For larger values of N, additional programming may be added to the MSA to improve the performance for very large arithmetic processors. This is shown in the column labeled "MSA n".

Table 1. Carry Lookahead Structure Comparison

In the general case, the worst case carry propagation time for an MSA style structure is given by the equation:

T = (M-l) Tf + (NIM) T_q (Eq. 11)

Where TVis the propagation delay for the P and G signal in each bit slice (function cell), Tq is the propagation delay of the intermediate carry signal from the ALU controller (one quad cell time), N is the total number of bits and M is the number of bits in an ALU block.

The optimal value of M to minimize the total time is given by the equation:

For this value, the worst case delay time is given by the equation:

Although the present invention has been descπbed in detail with reference to the preferred embodiments thereof, those skilled in the art will appreciate that vaπous substitutions and modifications can be made to the examples descπbed herein while remaining within the spiπt and scope of the invention as defined in the appended claims.

Claims

What is claimed is

1. A programmable logic device, comprising: a plurality N of function cells, each function cell being adapted to provide a respective bit result of an N-bit operation, the N function cells being arranged in blocks of respective sub-pluralities of cells per block; and an intermediate carry calculator associated with at least one of the blocks, the intermediate carry calculator calculating an intermediate carry result for the block based on a carry input received from another block associated with less significant bits in the N-bit operation, and signals corresponding to the bit result of the function cell associated with the most significant bit of the block.

2. A programmable logic device according to claim 1, wherein the signals are a combination of a propagate (P) and a generate (G) output from each function cell in the at least one block

3. A programmable logic device according to claim 2, wherein the intermediate carry calculator implements an equation of the form

C_out = G (OR) (C_ιn (AND) P), wherein C_out is the intermediate carry result, and C_m is the received carry input.

4. A programmable logic device according to claim 1 , further comprising a multiplexer that dynamically controls the number of cells per block.

5. A programmable logic device according to claim 1, wherein the intermediate carry calculator is operative such that a delay between a change m the received carry input and a change in the intermediate carry result is substantially a propagation time of the intermediate carry calculator.

6. A programmable device according to claim 1, further comprising an increment adjustment block that adjusts a provisional carry associated with the bit result of the function cells in accordance with an actual carry input for the respective blocks in which the function cells are arranged.

7. A programmable device according to claim 2, wherein each function cell implements a bit slice of a '74181 type ALU for generating the P and G outputs based on two single bit variable inputs and a received function code.

8. A programmable device according to claim 7, wherein the P and G outputs are combined m πpple fashion to provide the signals.

9. A method of implementing carry propagation in a programmable logic device, comprising: identifying N function cells for respectively providing a bit result of an N-bit operation; dividing the N function cells into blocks of respective sub-pluralities of function cells per block; calculating an intermediate carry result m at least one of the blocks based on a received carry from another one of the blocks associated with less significant bits in the N-bit operation, and signals corresponding to the bit result of the function cell associated with the most significant bit of the block.

10. A method according to claim 9, further comprising combining a propagate (P) and a generate (G) output from each function cell to generate the signals in the at least one block.

11. A method according to claim 10, wherein the calculating step implements an equation of the form

C_out = G (OR) (C_ιn (AND) P), wherein C_out is the intermediate carry result, and C_ιn is the received carry input.

12. A method according to claim 9, further compπsing: providing a multiplexer that dynamically controls the number of cells per block.

13. A method according to claim 1, wherein the intermediate carry calculation step is operative such that a delay between a change in the received carry input and a change in the intermediate carry result is substantially a propagation time associated with the intermediate carry calculation step.

14. A method according to claim 9, further comprising: adjusting a provisional carry associated with the bit result of the function cells in accordance with an actual carry input for the respective blocks in which the function cells are arranged.

15. A method according to claim 10, further comprising: implementing in each function cell a bit slice of a '74181 type ALU for generating the P and G outputs based on two single bit variable inputs and a received function code.

16. A method according to claim 15, further compπsing: combining the P and G outputs in πpple fashion to provide the signals.

17. An ALU block in a programmable logic device, comprising-

M function cells each generating signals corresponding to a respective bit in a multi-bit operation including a least significant bit to a most significant bit, the signals including a provisional carry signal that represents carry for the respective bit as a function of an assumed carry input to the ALU block, an actual carry input; an intermediate carry stage that receives the actual carry input and the signals from one of the M function cells associated with the most significant bit and generates an intermediate carry output; an increment adjustment stage that receives the signals from the M function cells and the actual carry input and adjusts the carry for each respective bit based on a difference between the assumed carry input and the actual carry input.

18. An N-bit ALU implemented in at least a portion of a programmable logic device, comprising: a carry input,

N variable inputs; a function input; a carry output;

N function cells, each respectively coupled to one of the vaπable inputs and the function input and generating signals based thereon; and

N/M intermediate carry calculators, each receiving an intermediate carry input and the signals from a respective M-th one of the function cells, and producing an intermediate carry result based thereon, wherein the intermediate carry input of a least significant one of the intermediate carry calculators is the carry input, the intermediate carry mput of the other of the intermediate carry calculators is the intermediate carry result of a less significant one of the intermediate carry calculators, and the intermediate carry result of a most significant one of the intermediate carry calculators is the carry output. 19 A method of propagating carry for an N-bit operation in at least a portion of a programmable logic device, the N bits being arranged in N/M groups of M bits, the method comprising receiving a carry input; generating signals respectively corresponding to a provisional carry result for each bit in the N-bit operation; calculating a first intermediate carry result based on the received carry input and the signal corresponding to an M-th bit of the N-bit operation; and calculating a second intermediate carry result based on the first intermediate carry result and the signal corresponding to a 2*M-th bit of the N-bit operation.