Complementary pass gate logic implementation of 64-bit arithmetic logic unit using propagate, generate, and kill

Abstract

An arithmetic logic unit (ALU) implemented with complementary pass gate logic using propagate, generate, and kill is provided. Broadly speaking, the ALU is a 64-bit ALU using a multi-stage global carry chain to generate intermediate fourth-bit carries that are folded with local four-bit sums to efficiently generate a final sum output. The ALU implements ones complement subtraction by incorporating a subtraction select signal to invert each bit of a second operand. The ALU circuitry implements a push-pull methodology to improve performance.

Description

BACKGROUND OF THE INVENTION

1. Field of the Invention

The present invention relates generally to microprocessors, and more particularly, to an arithmetic logic unit.

2. Description of the Related Art

An arithmetic logic unit (ALU) is a module of circuitry capable of realizing a set of arithmetic and logic functions. In general the ALU receives a set of input data and creates a set of output data. The input and output data are processed in binary form by the ALU. The ALU is generally used as a standard module in microprocessors. In this manner the same ALU can be used in many different applications. One primary purpose of the ALU in the microprocessor is to perform integer addition operations. It is typical for multiple ALU's to be used in systems that are required to perform large numbers of integer addition operations. As such the ALU characteristics described in terms of speed, power consumption, and chip footprint area become important microprocessor design considerations.

Most ALU's of modern computing system are implemented using dynamic circuitry. Dynamic circuitry is generally used to improve the speed of the ALU. However, use of dynamic circuitry introduces a number of drawbacks with respect to overall system design. For instance, use of dynamic circuitry results in high power consumption and occupation of a large chip footprint area. Also, due to heavy reliance on timing and reference clocks, dynamic circuitry is vulnerable to noise perturbations. Therefore, a large amount of effort and expense must be invested in the successful design of an ALU using dynamic circuitry.

As an alternative to dynamic circuitry, regular static circuitry can be used to implement an ALU. The ALU implemented using regular static circuitry has a lower power consumption and a smaller chip footprint area as compared to the ALU implemented using dynamic circuitry. The use of regular static circuitry also yields a more robust ALU that is less vulnerable to noise perturbations. However, the computational speed of the ALU implemented using regular static circuitry is generally not competitive with an ALU implemented using dynamic circuitry.

In view of the foregoing, there is a need for an ALU that combines the beneficial characteristics of a dynamically implemented ALU and a regular statically implemented ALU. More specifically, there is a need for an ALU that offers the high speed of a dynamically implemented ALU while also offering the low power consumption and the small chip footprint area of regular statically implemented ALU.

SUMMARY OF THE INVENTION

Broadly speaking, the present invention fills these needs by providing an arithmetic logic unit (ALU) implemented with complementary pass gate logic using propagate, generate, and kill. The ALU uses a multi-stage global carry chain to generate intermediate fourth-bit carries that are folded with local four-bit sums to efficiently generate a final sum output. The ALU also implements ones complement subtraction by incorporating a subtraction select signal to invert each bit of a second operand. Also, the circuitry of the ALU implements a push-pull methodology to improve performance. It should be appreciated that the present invention can be implemented in numerous ways, including as a process, an apparatus, a system, a device, or a method. Several embodiments of the present invention are described below.

In one embodiment, arithmetic logic processing circuitry is disclosed. The arithmetic logic processing circuitry includes a global carry chain implementing static propagate, kill, and generate circuitry. The global carry chain includes a first stage, a second stage, a third stage, and a fourth stage. The first stage is for generating first propagate, kill, and generate signals for each bit of a pair of multi-bit signal vectors. The second stage is for generating second propagate, kill, and generate signals for a first group of the first propagate, kill, and generate signals. The third stage is for generating third propagate, kill, and generate signals for a first group of the second propagate, kill, and generate signals. The fourth stage is for generating carry signals and carry complement signals. The fourth stage is configured to receive inputs from each of the second stage and the third stage. The carry signals and the carry complement signals generated by the fourth stage are useful for generating one of a sum result and a subtraction result.

In another embodiment, a method for making arithmetic logic processing circuitry is disclosed. The method includes implementing a global carry chain using static propagate, kill, and generate circuitry. The global carry chain is implemented by implementing a first stage, a second stage, a third stage, and a fourth stage. Implementation of the first stage is performed to generate first propagate, kill, and generate signals for each bit of a pair of multi-bit signal vectors. Implementation of the second stage is performed to generate second propagate, kill, and generate signals for a first group of the first propagate, kill, and generate signals. Implementation of the third stage is performed to generate third propagate, kill, and generate signals for a first group of the second propagate, kill, and generate signals. Implementation of the fourth stage is performed to generate carry signals and carry complement signals. The fourth stage is implemented to receive inputs from each of the second stage and the third stage. The carry signals and the carry complement signals generated by implementation of the fourth stage are useful for generating one of a sum result and a subtraction result.

In another embodiment, arithmetic logic unit circuitry is disclosed. The arithmetic logic unit circuitry includes a multi-stage global carry chain. The multi-stage global carry chain implements static propagate, kill, and generate circuitry for generating carry signals associated with a pair of multi-bit signal vectors. The carry signals are useful for generating one of a sum result and a subtraction result for the pair of multi-bit signal vectors. The arithmetic logic unit circuitry also includes a summation processing circuit for creating sum and sum complement signals for each bit in the pair of multi-bit signal vectors. The summation processing circuit is further configured to fold the sum and sum complement signals with the carry signals to produce a final sum output signal vector.

Other aspects of the invention will become more apparent from the following detailed description, taken in conjunction with the accompanying drawings, illustrating by way of example the present invention.

BRIEF DESCRIPTION OF THE DRAWINGS

The invention, together with further advantages thereof, may best be understood by reference to the following description taken in conjunction with the accompanying drawings in which:

FIG. 1 is an illustration showing an arithmetic logic unit (ALU), in accordance with one embodiment of the present invention;

FIGS. 2A–2B show a diagram of data flow through the four stages of the global carry chain, in accordance with one embodiment of the invention;

FIGS. 3A–3B show a diagram of data flow through the local sum and sum complement block and the sum select block, in accordance with one embodiment of the invention;

FIG. 4A is an illustration showing an exemplary circuit implementing the first stage of the global carry chain for a bit-i, in accordance with one embodiment of the invention;

FIG. 4B is an illustration showing an exemplary circuit implementing the second stage of the global carry chain for bit-0 through bit-3, in accordance with one embodiment of the invention;

FIG. 4C is an illustration showing an exemplary circuit implementing the third stage of the global carry chain for the first through fourth group of four bits each from the second stage, in accordance with one embodiment of the invention;

FIG. 4D is an illustration showing an exemplary circuit implementing the fourth stage of the global carry chain for creating a carry (C_51—0) and a carry complement signal (C_51—0′) corresponding to bit-0 through bit-51, in accordance with one embodiment of the invention;

FIG. 4E is an illustration showing an exemplary circuit implementing the fourth stage of the global carry chain for creating a carry (C_19—0) and a carry complement signal (C_19—0′′) corresponding to bit-0 through bit-19, in accordance with one embodiment of the invention;

FIG. 5A is an illustration showing a first portion of an exemplary circuit implementing the local sum and sum complement generation block, in accordance with one embodiment of the invention;

FIG. 5B is an illustration showing a second portion of the exemplary circuit implementing the local sum and sum complement generation block, in accordance with one embodiment of the invention; and

FIG. 6 is an illustration showing a critical path block diagram for the ALU including the global carry chain and the sum and logic block, in accordance with one embodiment of the invention.

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS

An invention is disclosed for an arithmetic logic unit (ALU) implemented with complementary pass gate logic using propagate, generate, and kill. Broadly speaking, the present invention is a 64-bit ALU that uses a multi-stage global carry chain to generate intermediate fourth-bit carries that can be folded with local four-bit sums to efficiently generate a final sum output. The ALU of the present invention also implements ones complement subtraction by incorporating a subtraction select signal to invert each bit of a second operand. Additionally, the circuitry of the ALU of the present invention implements a push-pull methodology to improve performance. As compared to an ALU implemented using dynamic circuitry, the ALU of the present invention uses less power, occupies less area, has comparable speed, and is more robust.

In the following description, numerous specific details are set forth in order to provide a thorough understanding of the present invention. It will be apparent, however, to one skilled in the art that the present invention may be practiced without some or all of these specific details. In other instances, well known process operations have not been described in detail in order not to unnecessarily obscure the present invention.

FIG. 1 is an illustration showing an ALU, in accordance with one embodiment of the present invention. The ALU includes a global carry chain 101 and a sum and logic block 103. The sum and logic block 103 receives a 64-bit signal vector (rs1) and a 64-bit signal vector (rs2) into an operand select multiplexer 105 through communication pathways 111 and 113, respectively.

If a logic operation is to be performed, the operand select multiplexer 105 passes a signal indicating such through a communication pathway 117 to a logic operations block 109. The operand select multiplexer 105 will also pass rs1 and rs2 to the logic operations block 109. The logic operations block 109 is capable of performing a plurality of logical operations on rs1 and rs2. In one embodiment the logic operations block 109 will perform operations such as AND, ANDcc, ANDN, ANDNcc, OR, ORcc, ORN, ORNcc, XOR, XORcc, XNOR, and XNORcc. In other embodiments, the logic operations block 109 will be capable of performing other well known logical operations on rs1 and rs2. The logic operations block 109 passes a logic operation result to a sum/logic select multiplexer 123 through a communication pathway 125. If a logic operation is to be performed, the sum/logic select multiplexer 123 will pass the logic operation result through a communication pathway 127 to a sum select block 129. If a logic operation is to be performed, the logic operation result will be passed from the sum select block 129 through a communication pathway 131 as a logic output.

If an addition or subtraction operation is to be performed, the operand select multiplexer 105 passes a signal indicating such through a communication pathway 115 to a local sum and sum complement generation block 107. Bit-wise propagate, kill, and generate signals are passed through a communication pathway 133 from a first stage 137 of the global carry chain 101 to the local sum and sum complement generation block 107. Using the bit-wise propagate, kill, and generate signals, the local sum and sum complement generation block 107 creates a sum and a sum complement for each consecutive group of four bits between bit-0 and bit-63. The sum and sum complement for each consecutive group of four bits are passed through a communication pathway 135 to the sum/logic select multiplexer 123. If an addition or subtraction operation is to be performed, the sum/logic select multiplexer 123 will pass the sum and sum complement for each consecutive group of four bits through the communication pathway 127 to the sum select block 129. A carry and carry complement corresponding to bit-0 through bit-j for every fourth bit-j is provided from a fourth stage 149 of the global carry chain 101 through a communication pathway 151 to be used as input to the sum select block 129. The sum select block 129 folds the carry and carry complement input with the sum and sum complement input to determine a final sum output. The final sum output is provided from the sum select block 129 through a communication pathway 131.

The global carry chain 101 includes the first stage 137, a second stage 141, a third stage 145, and the fourth stage 149. The first stage 137 receives rs1, rs2, and a subtraction select signal as input through communication pathways 155, 157, and 159, respectively. Output from the first stage 137 is provided through a communication pathway 139 to the second stage 141 and also through a communication pathway 133 to the local sum and sum complement generation block 107. Output from the second stage 141 is provided through a communication pathway 143 to the third stage 145 and also through a communication pathway 161 to the fourth stage 149. Output from the third stage 145 is provided through a communication pathway 147 to the fourth stage 149. The fourth stage 149 provides carry and carry complement output through communication pathway 151 to the sum select block 129. The fourth stage 149 also provides a carry output signal through a communication pathway 153. The following discussion provides details corresponding to the implementation of the four stages of the global carry chain 101.

FIGS. 2A–2B show a diagram of data flow through the four stages of the global carry chain 101, in accordance with one embodiment of the invention. The 64-bit signal vector (rs1), the 64-bit signal vector (rs2), and the subtraction select signal are passed to the first stage 137 of the global carry chain 101. In the first stage 137, a propagate signal, a kill signal, and a generate signal are created for each of the 64 bits (i.e., bit-0 through bit-63). The first stage 137 also combines the subtraction select signal with the creation of the propagate, kill, and generate signals to implement one's complement subtraction. When the subtraction select signal is high, rs2 is to be subtracted from rs1. A high subtraction select signal essentially causes the complement of rs2 (i.e., rs2′) to be added to rs1. In rs2′, each high bit of the rs2 signal vector becomes low and, conversely, each low bit of the rs2 signal vector becomes high. Thus, when the subtraction select signal is high, one's complement subtraction is performed by adding rs2′ (i.e., the complement of rs2) to rs1. Table 1 presents the equations used to implement the first stage 137 of the global carry chain 101.

The second stage 141 of the global carry chain 101 is implemented on consecutive groups of four bits beginning with the group defined by bit-0 through bit-3 and ending with the group defined by bit-60 through bit-63. The second stage 141 creates a four-bit propagate signal, a four-bit kill signal, and a four-bit generate signal for each of the sixteen consecutive groups of four bits between bit-0 and bit-63. The propagate, kill, and generate signals for each bit as previously created in stage one 137 are used as input to the second stage 141. For example, the propagate (P₀, P₁, P₂, P₃), kill (K₀, K₁, K₂, K₃), and generate (G₀, G₁, G₂, G₃) signals for bit-0 through bit-3 are used in the second stage 141 to create the propagate (P_3—0), kill (K_3—0), and generate (G_3—0) signals corresponding to the first group of four bits. As another example, the propagate (P₆₀, P₆₁, P₆₂, P₆₃), kill (K₆₀, K₆₁, K₆₂, K₆₃), and generate (G₆₀, G₆₁, G₆₂, G₆₃) signals for bit-60 through bit-63 are used in the second stage 141 to create the propagate (P₆₃₆₀), kill (K_63—60), and generate (G_63—60) signals corresponding to the sixteenth group of four bits. Tables 2A, 2B, and 2C present the equations used to implement the second stage 141 of the global carry chain 101.

The third stage 145 of the global carry chain 101 creates thirteen sets of propagate, kill, and generate signals, wherein each set is based on four successive groups of propagate, kill, and generate signals created in the second stage 141. For example, the first set of propagate (P_15—0), kill (K₁₅₀), and generate (G₁₅₀) signals in the third stage 145 represents a combination of the first through fourth group of four bits each (P_3—0, K₃₀, G_3—0, P_7—4, K_7—4, G₇₄, P_11—8, K_11—8, G₁₁₈, P_15—12, K_15—12, and G_15—12) from the second stage 141. Continuing with the example, the second set of propagate (P_19—4), kill (K_19—4), and generate (G_19—4) signals in the third stage 145 represents a combination of the second through fifth group of four bits each (P_7—4, K_7—4, G_7—4, P_11—8, K_11—8, G_11—8, P_15—12, K_15—12, G_15—12, P_19—16, K_19—16, and G_19—16) from the second stage 141. The remainder of the third stage 145 propagate, kill, and generate signals are created in the same manner. Hence, the thirteenth set of propagate (P_63—48), kill (K_63—48), and generate (G_63—48) signals in the third stage 145 represents a combination of the thirteenth through sixteenth group of four bits each (P_51—48, K_51—48, G_51—48, P_55—52, K_55—52, G_55—52, P_59—56, K_{59 —56}, G_59—56, P_63—60, K_63—60, and G_63—60) from the second stage 141. Tables 3A, 3B, and 3C present the equations used to implement the third stage 145 of the global carry chain 101.

The fourth stage 149 of the global carry chain 101 creates a carry (C_j—0) and a carry complement signal (C_j—0′) corresponding to bit-0 through bit-j for every fourth bit-j (i.e., bit-3, bit-7, bit-11, bit-15, bit-19, bit-23, bit-27, bit-31, bit-35, bit-39, bit-43, bit-47, bit-51, bit-55, bit-59, bit-63). The propagate, kill, and generate signals created by the first three groups in the second stage 141 (i.e., P_3—0, K_3—0, G_3—0, P_7—4, K_7—4, G_7—4, P_11—8, K_11—8, and G_11—8) along with each set of propagate, kill, and generate signals created by the third stage 145 are used in various combinations to create each C_j—0 and C_j—0′ in the fourth stage 149. Tables 4A and 4B present the equations used to implement the fourth stage 149 of the global carry chain 101.

FIGS. 3A–3B show a diagram of data flow through the local sum and sum complement block 107 and the sum select block 129, in accordance with one embodiment of the invention. The data created by the local sum and sum complement block 107 is shown in block 207. The propagate, kill, and generate signals created for each of the 64 bits (i.e., bit-0 through bit-63) in the first stage 137 are used to create a sum (Z_j for bit-j) signal and a sum complement (Z_j′ for bit-j) signal for each bit in the sum and sum complement block 107. The Z_j and Z_j′ signals are determined based on a 4-bit adder methodology assuming a carry-in (C_in) of 1 for the Z_j signals and a C_in of 0 for Z_j′ signals. Thus, the propagate, kill, and generate signals from the first stage 137 for each consecutive group of 4 bits from bit-0 through bit-63 are passed through a dual 4-bit adder implementing both C_in=1 and C_in=0. For example, the propagate, kill, and generate signals for bit-0 through bit-3 are passed through a 4-bit adder that uses a C_in=1 to create a set of sum signals including Z₀, Z₁, Z₂, and Z₃. The propagate, kill, and generate signals for bit-0 through bit-3 are also passed through a 4-bit adder that uses a C_in=0 to create a set of sum signals including Z₀′, Z₁′, Z₂′, and Z₃′. Each consecutive group of 4 bits are processed in this manner until the final group including bit-60 through bit-63 are processed to create a set of signals including Z₆₀, Z₆₁, Z₆₂, Z₆₃ Z₆₀′, Z₆₁′, Z₆₂′, and Z₆₃′. Tables 5 presents the equations used to create the sum and sum complement for each bit as previously described.

The Z_j and Z_j′ signals for each bit are passed from the local sum and sum complement block 107 to the sum select block 129, as indicated by the plurality of arrows positioned between the block 207 and a block 229 in FIGS. 3A–3B. The data flow shown in block 229 generally describes the processing performed by the sum select block 129. Depending on the signal value of the cumulative preceding carry-in, the sum select block 129 provides either Z_j or Z_j′ to an output signal vector (Sum Out 225). If the cumulative preceding carry-in value (i.e., the carry-in value for bit-0 through bit-j) is high, the sum select block 129 will provide the Z_j signals for the next four bits (i.e., bit-(j+1), bit-(j+2), bit-(j+3), and bit-(j+4) to corresponding bits in Sum Out 225. If the cumulative preceding carry-in value (i.e., the carry-in value for bit-0 through bit-j) is low, the sum select block 129 will provide the Z_j′ signals for the next four bits (i.e., bit-(j+1), bit-(j+2), bit-(j+3), and bit-(j+4) to corresponding bits in Sum Out 225. In this manner the Sum Out 225 signal vector is created and represents the final sum output that is provided from the sum select block 129 through the communication pathway 131. Also, the carry output signal provided through communication pathway 153 from the fourth stage 149 represents a cumulative carry from bit-0 through bit-63 (i.e., C_63—0). A high C_63—0 signal is used to indicate an overflow condition.

FIG. 4A is an illustration showing an exemplary circuit implementing the first stage 137 of the global carry chain 101 for a bit-i, in accordance with one embodiment of the invention. The bit-i circuitry for the first stage 137 receives as input a signal (rs1_i) from bit-i of signal vector rs1, a signal (rs2_i) from bit-i of signal vector rs2, and a subtraction selection signal (sel). The bit-i circuitry for the first stage 137 implements the equations presented in Table 1 to generate a propagate signal for bit-i (P_i), a kill signal for bit-i (K_i), and a generate signal for bit-i (G_i). Per the equations in Table 1, only one of P_i, K_i, and G_i can be high for a given bit-i. The bit-i circuitry for the first stage 137 takes advantage of this fact to incorporate a push-pull methodology to enhance the corresponding circuit performance.

If either P_i, K_i, or G_i is to be generated as a high signal, the corresponding signal prior to inverters 415, 413, or 417, respectively, will be low. Similarly, if either P_i, K_i, or G_i is to be generated as a low signal, the corresponding signal prior to inverter 415, 413, or 417, respectively, will be high. Just prior to entering the inverters 415, 413, or 417, the one low signal will cause the two high signals to be pushed high (i.e., refreshed). Thus, when passing through the inverters 415, 413, or 417, the two recently refreshed high signals will be inverted to two well-defined low signals, and the one low signal will inverted to one well-defined high signal. A low P_i signal prior to inverter 415 causes PMOS devices 419 and 427 to refresh the high K_i and G_i signals, respectively, prior to inverters 413 and 417, respectively. A low K_i signal prior to inverter 413 causes PMOS devices 423 and 429 to refresh the high P_i and G_i signals, respectively, prior to inverters 415 and 417, respectively. A low G_i signal prior to inverter 417 causes PMOS devices 421 and 425 to refresh the high K_i and P_i signals, respectively, prior to inverters 413 and 415, respectively. In this manner, the push-pull methodology is implemented to enhance the corresponding circuit performance.

FIG. 4B is an illustration showing an exemplary circuit implementing the second stage 141 of the global carry chain 101 for bit-0 through bit-3, in accordance with one embodiment of the invention. The exemplary circuitry for the second stage 141 receives as input a set of propagate, kill, and generate signals for each bit. For bit-0, a propagate signal (P₀), a kill signal (K₀), and a generate signal (G₀) is received as input. For bit-1, a propagate signal (P₁), a kill signal (K₁), and a generate signal (G₁) is received as input. For bit-2, a propagate signal (P₂), a kill signal (K₂), and a generate signal (G₂) is received as input. For bit-3, a propagate signal (P₃), a kill signal (K₃), and a generate signal (G₃) is received as input. The exemplary circuitry for the second stage 141 implements the equations presented in Tables 2A, 2B, and 2C to generate a propagate signal (P_3—0), a kill signal (K_3—0), and a generate signal (G_3—0), for the set of bits from bit-0 through bit-3. Per the equations in Tables 2A, 2B, and 2C, only one of P_3—0, K_3—0, and G_3—0 can be high at a given time. The circuitry for the second stage 141 takes advantage of this fact to incorporate a push-pull methodology to enhance the corresponding circuit performance.

If either P_3—0, K_3—0, or G_3—0 is to be generated as a high signal, the corresponding signal prior to inverters 481, 479, or 477, respectively, will be low. Similarly, if either P_3—0, K_3—0, or G_3—0 is to be generated as a low signal, the corresponding signal prior to inverter 481, 479, or 477, respectively, will be high. Just prior to entering the inverters 481, 479, or 477, the one low signal will cause the two high signals to be pushed high (i.e., refreshed). Thus, when passing through the inverters 481, 479, or 477, the two recently refreshed high signals will be inverted to two well-defined low signals, and the one low signal will inverted to one well-defined high signal. A low P_3—0 signal prior to inverter 481 causes PMOS devices 471 and 467 to refresh the high K_3—0 and G_3—0 signals, respectively, prior to inverters 479 and 477, respectively. A low K_3—0 signal prior to inverter 479 causes PMOS devices 475 and 465 to refresh the high P_3—0 and G_3—0 signals, respectively, prior to inverters 481 and 477, respectively. A low G_3—0 signal prior to inverter 477 causes PMOS devices 469 and 473 to refresh the high K_3—0 and P_3—0 signals, respectively, prior to inverters 479 and 481, respectively. In this manner, the push-pull methodology is implemented to enhance the corresponding circuit performance. In other embodiments of the present invention, a plurality of PMOS devices can be implemented in a similar manner at other locations within the circuit where a pair of signals are mutually exclusive. In this manner, the low signal in the pair of signals is used to control a PMOS device configured to refresh the complementary high signal in the pair of signals.

FIG. 4C is an illustration showing an exemplary circuit implementing the third stage 145 of the global carry chain 101 for the first through fourth group of four bits each from the second stage 141, in accordance with one embodiment of the invention. The exemplary circuitry for the third stage 145 receives as input a set of propagate, kill, and generate signals for the first through fourth group of four bits each from the second stage 141 (i.e., P_3—0, K_3—0, G_3—0, P_7—4, K_7—4, G_7—4, P_11—8, K_11—8, G_11—8, P_15—12, K_15—12, For the first group of four bits, a propagate signal (P_3—0), a kill signal (K_3—0), and a generate signal (G_3—0) is received as input. For the second group of four bits, a propagate signal (P_7—4), a kill signal (K_7—4), and a generate signal (G_7—4) is received as input. For the third group of four bits, a propagate signal (P_11—8), a kill signal (K_11—8), and a generate signal (G_11—8) is received as input. For the fourth group of four bits, a propagate signal (P_15—12), a kill signal (K_15—12), and a generate signal (G_15—12) is received as input. The exemplary circuitry for the third stage 145 implements the equations presented in Tables 3A, 3B, and 3C to generate a propagate signal (P_15—0), a kill signal (K_15—0), and a generate signal (G_15—0), for the first through fourth group of four bits each from the second stage 141. Per the equations in Tables 3A, 3B, and 3C, only one of P_15—0, K_15—0, and G_15—0 can be high at a given time. The circuitry for the third stage 145 takes advantage of this fact to incorporate a push-pull methodology to enhance the corresponding circuit performance.

If either P_15—0, K_15—0, or G_15—0 is to be generated as a high signal, the corresponding signal prior to inverters 499, 497, or 495, respectively, will be low. Similarly, if either P_15—0, K_15—0, or G_15—0 is to be generated as a low signal, the corresponding signal prior to inverter 499, 497, or 495, respectively, will be high. Just prior to entering the inverters 499, 497, or 495, the one low signal will cause the two high signals to be pushed high (i.e., refreshed). Thus, when passing through the inverters 499, 497, or 495, the two recently refreshed high signals will be inverted to two well-defined low signals, and the one low signal will inverted to one well-defined high signal. A low P_15—0 signal prior to inverter 499 causes PMOS devices 487 and 485 to refresh the high K_15—0 and G_15—0 signals, respectively, prior to inverters 497 and 495, respectively. A low K_15—0 signal prior to inverter 497 causes PMOS devices 493 and 483 to refresh the high P_15—0 and G_15—0 signals, respectively, prior to inverters 499 and 495, respectively. A low G_15—0 signal prior to inverter 495 causes PMOS devices 489 and 491 to refresh the high K_15—0 and P_15—0 signals, respectively, prior to inverters 497 and 499, respectively. In this manner, the push-pull methodology is implemented to enhance the corresponding circuit performance. In other embodiments of the present invention, a plurality of PMOS devices can be implemented in a similar manner at other locations within the circuit where a pair of signals are mutually exclusive. In this manner, the low signal in the pair of signals is used to control a PMOS device configured to refresh the complementary high signal in the pair of signals.

FIG. 4D is an illustration showing an exemplary circuit implementing the fourth stage 149 of the global carry chain 101 for creating a carry (C_51—0) and a carry complement signal (C_51—0′) corresponding to bit-0 through bit-51, in accordance with one embodiment of the invention. The exemplary circuitry for creating C_51—0 and C_51—0′ receives as input a generate signal (G_3—0) and a kill signal (K_3—0) for bit-0 through bit-3 from the second stage 141. Also, the exemplary circuitry receives as input a propagate signal (P_19—4), a kill signal (K_19—4), and a generate signal (G_19—4) corresponding to bit-4 through bit-19 from the third stage 145. Also, the exemplary circuitry receives as input a propagate signal (P_35—20), a kill signal (K_35—20), and a generate signal (G_35—20) corresponding to bit-20 through bit-35 from the third stage 145. Also, the exemplary circuitry receives as input a propagate signal (P_51—36), a kill signal (K_51—36), and a generate signal (G_51—36) corresponding to bit-36 through bit-51 from the third stage 145. The exemplary circuitry for the fourth stage 149 implements the equations for C_51—0 and C_51—0′ presented in Tables 4A and 4B. Per the equations in Tables 4A and 4B, only one of C_51—0 and C_51—0′ can be high at a given time. The circuitry for the fourth stage 149 takes advantage of this fact to incorporate a push-pull methodology to enhance the corresponding circuit performance.

If either C_51—0 or C_51—0′ is to be generated as a high signal, the corresponding signal prior to inverter 519 or 521, respectively, will be low. Similarly, if either C_51—0 or C_51—0′ is to be generated as a low signal, the corresponding signal prior to inverter 519 or 521, respectively, will be high. Just prior to entering the inverter 519 or 521, the low signal will cause the high signal to be pushed high (i.e., refreshed). Thus, when passing through the inverter 519 or 521, the recently refreshed high signal will be inverted to a well-defined low signal, and the low signal will inverted to a well-defined high signal. A low C_51—0 signal prior to inverter 519 causes PMOS device 517 to refresh the high C_51—0′ signal prior to inverter 521. A low C_51—0′ signal prior to inverter 521 causes PMOS device 515 to refresh the high C_51—0 signal prior to inverter 519. In this manner, the push-pull methodology is implemented to enhance the corresponding circuit performance. In other embodiments of the present invention, a plurality of PMOS devices can be implemented in a similar manner at other locations within the circuit where a pair of signals are mutually exclusive. For example, a signal at a node 510a is mutually exclusive with a signal at a node 510b. Therefore, a plurality of PMOS devices 511 and 513 can be used to implemented the push-pull methodology. A low signal prior at node 510a causes PMOS device 513 to refresh a high signal prior to a pass gate 512. A low signal at node 510b causes PMOS device 511 to refresh a high signal prior to a pass gate 514. In this manner, the low signal in the pair of signals is used to control a PMOS device configured to refresh the complementary high signal in the pair of signals.

FIG. 4E is an illustration showing an exemplary circuit implementing the fourth stage 149 of the global carry chain 101 for creating a carry (C_19—0) and a carry complement signal (C_19—0′) corresponding to bit-0 through bit-19, in accordance with one embodiment of the invention. The exemplary circuitry for creating C_19—0 and C_19—0′ receives as input a generate signal (G_3—0) and a kill signal (K_3—0) for bit-0 through bit-3 from the second stage 141. Also, the exemplary circuitry receives as input a propagate signal (P_19—4), a kill signal (K_19—4), and a generate signal (G_19—4) corresponding to bit-4 through bit-19 from the third stage 145. The exemplary circuitry for the fourth stage 149 implements the equations for C_19—0 and C_19—0′ presented in Tables 4A and 4B. Per the equations in Tables 4A and 4B, only one of C_19—0 and C_19—0′ can be high at a given time. The circuitry for the fourth stage 149 takes advantage of this fact to incorporate a push-pull methodology to enhance the corresponding circuit performance.

If either C_19—0 or C_19—0′ is to be generated as a high signal, the corresponding signal prior to inverter 543 or 545, respectively, will be low. Similarly, if either C_19—0 or C_19—0′ is to be generated as a low signal, the corresponding signal prior to inverter 543 or 545, respectively, will be high. Just prior to entering the inverter 543 or 545, the low signal will cause the high signal to be pushed high (i.e., refreshed). Thus, when passing through the inverter 543 or 545, the recently refreshed high signal will be inverted to a well-defined low signal, and the low signal will inverted to a well-defined high signal. A low C_19—0 signal prior to inverter 543 causes PMOS device 539 to refresh the high C_19—0′ signal prior to inverter 545. A low C_19—0′ signal prior to inverter 545 causes PMOS device 541 to refresh the high C_19—0 signal prior to inverter 543. In this manner, the push-pull methodology is implemented to enhance the corresponding circuit performance.

FIG. 5A is an illustration showing a first portion of an exemplary circuit implementing the local sum and sum complement generation block 107, in accordance with one embodiment of the invention. The exemplary circuitry for the local sum and sum complement generation block 107 implements the equations presented in Table 5. The exemplary circuitry of FIG. 5A is shown as being implemented for bit-0 through bit-3. A similar first portion of exemplary circuitry is implemented for each four bit group corresponding to bit-i, bit-(i+1), bit-(i+2), and bit-(i+3) as shown in Table 5. The first portion of the exemplary circuitry for the local sum and sum complement generation block 107 receives as input a generate signal for bit-0 (G₀), a kill signal for bit-0 (K₀), a propagate signal for bit-1 (P₁), a generate signal for bit-i (G₁), a propagate signal for bit-2 (P₂), and a generate signal for bit-2 (G₂). Using the gate logic as shown in FIG. 5A, the first portion of the exemplary circuitry for the local sum and sum complement generation block 107 generates intermediate carries for bit-1 through bit-3 assuming that C_in (i.e., the actual carry into bit-0) is both high (C_in=1) and low (C_in=0). Output signals C₁ (C_in=1) and C₁ (C_in=0) correspond to intermediate carries for bit-1 assuming that C_in is high and low, respectively. Output signals C₂ (C_in=1) and C₂ (C_in=0) correspond to intermediate carries for bit-2 assuming that C_in is high and low, respectively. Output signals C₃ (C_in=1) and C₃ (C_in=0) correspond to intermediate carries for bit-3 assuming that C_in is high and low, respectively. The output signals C₁ (C_in=1), C₁ (C_in=0), C₂ (C_in=1), C₂ (C_in=0), C₃ (C_in=1), and C₃ (C_in=0) are provided as input to a second portion of the exemplary circuit implementing the local sum and sum complement generation block 107.

FIG. 5B is an illustration showing a second portion of the exemplary circuit implementing the local sum and sum complement generation block 107, in accordance with one embodiment of the invention. The exemplary circuitry of FIG. 5B is shown as being implemented for bit-0 through bit-3. A similar second portion of exemplary circuitry is implemented for each four bit group corresponding to bit-i, bit-(i+1), bit-(i+2), and bit-(i+3) as shown in Table 5. In addition to the C₁ (C_in=1), C₁ (C_in=0), C₂ (C_in=1), C₂ (C_in=0), C₃ (C_in=1), and C₃ (C_in=0) input signals received from the first portion of exemplary circuitry, the second portion of exemplary circuitry for the local sum and sum complement generation block 107 receives as input a propagate signal for bit-0 (P₀), a propagate signal for bit-1 (P₁), a propagate signal for bit-2 (P₂), and a propagate signal for bit-3 (P₃). A sel_sum signal, a sel_zero signal, a sel_logic signal, a sel_zero_—1 signal, a sel_logic′ signal, and a logic_result[3:0] signal are also received as input by the second portion of exemplary circuitry for the local sum and sum complement generation block 107. The sel_sum signal is a control signal for instructing multiplexers to provide a local sum result versus a local logic result or a zero result. The sel_zero signal is a control signal for instructing multiplexers to provide a zero result versus a local sum or a local logic result. The sel_logic signal is a control signal for instructing multiplexers to provide a local logic result versus a local sum result or a zero result. The sel_zero_—1 signal is the same as the sel_zero signal except that the sel_zero_—1 signal is active low. The sel_logic′ signal is the complement of the sel_logic signal. The logic_result[3:0] signal is actually a four bit signal carried on a four bit bus. The logic_result[3:0] signal provides a bit-wise result of a logic operation. The associated logic operation is performed outside of the circuitry shown in FIG. 5B. Multiplexers 607a, 607b, 605, 603, and 601 are used to generate local sum and sum complement signals for bit-0, bit-1, bit-2, and bit-3, respectively. The circuitry contained within multiplexers 603 and 605 is analogous to the circuitry shown within multiplexer 601. Multiplexers 607a and 607b pass the appropriate signal depending on the sel_sum, sel_zero, and sel_logic signals. Local sum and sum complement signals for bit-0 (i.e., Z₀ and Z₀′, respectively) are passed to a multiplexer 609. Local sum and sum complement signals for bit-1 (i.e., Z₁ and Z₁′, respectively) are passed to a multiplexer 615. Local sum and sum complement signals for bit-2 (i.e., Z₂ and Z₂′, respectively) are passed to a multiplexer 613. Local sum and sum complement signals for bit-3 (i.e., Z₃ and Z₃′, respectively) are passed to a multiplexer 611. The actual carry signal into bit-0 (C_in) is provided to multiplexers 609, 615, 613, and 611. If C_in is high (C_in=1), the Z₀, Z₁, Z₂, and Z₃ signals will be passed as sum output signals S₀, S₁, S₂, and S₃, respectively. Conversely, if C_in is low (C_in=0), the Z₀′, Z₁′, Z₂′, and Z₃′ signals will be passed as sum output signals S₀, S₁, S₂, and S₃, respectively. As previously discussed with respect to FIGS. 3A–3B, the sum output signals S₀, S₁, . . . , S₆₃ define the final sum output.

FIG. 6 is an illustration showing a critical path block diagram for the ALU including the global carry chain 101 and the sum and logic block 103, in accordance with one embodiment of the invention. The critical path includes the first stage 137 receiving input rs1, rs2, and subtraction select. Output from the first stage 137 is provided to the second stage 141 along a first critical path branch. Output from the first stage 137 is also provided to the local sum and sum complement generation block 107 along a second critical path branch. Along the second critical path branch, output from the local sum and sum complement generation block 107 is provided to the sum select block 129. Along the first critical path branch, output from the second stage 141 is provided to the third stage 145. Output from the second stage 141 and third stage 145 is provided to the fourth stage 149. Output from the fourth stage 149 is then provided to the sum select block 129 which in turn provides the Final Sum Output. As shown by the equation for C_59—0 in Table 4A, the first critical path branch, corresponding to the global carry chain 101, is governed by the generation of the C_59—0. The critical path timing of the ALU of the present invention is generally comparable to that of an ALU implemented using dynamic circuitry and is substantially less than that of an ALU implemented using regular static circuitry.

In general, the ALU of the present invention can be implemented with a footprint area comparable to that of an ALU implemented using regular static circuitry. In following, the ALU of the present invention can be implemented with a footprint area substantially less than that of an ALU implemented using dynamic circuitry. Also, a power consumption associated with the ALU of the present invention is comparable to that of an ALU implemented using regular static circuitry. In following, the power consumption associated with the ALU of the present invention is substantially less than that of an ALU implemented using dynamic circuitry. Furthermore, since the ALU of the present invention does not rely on clocking, as is done in an ALU implemented using dynamic circuitry, the ALU of the present invention is more robust (e.g., less sensitive to noise) than an ALU implemented using dynamic circuitry.

TABLE 1

First Stage Propagate, Kill, and Generate Equations

First Stage Propagate Equations
Pi = rs1i XOR rs2i XOR select
for i = 0 . . . 63
Examples: P0 = rs10 XOR rs20 XOR select
          P1 = rs11 XOR rs21 XOR select
          P2 = rs12 XOR rs22 XOR select
          .
          .
          .
          P62 = rs162 XOR rs262 XOR select
          P63 = rs163 XOR rs263 XOR select
First Stage Kill Equations
Ki = rs1i′ AND (rs2i XNOR select)
for i = 0 . . . 63
Examples: K0 = rs10′ AND (rs20 XNOR select)
          K1 = rs11′ AND (rs21 XNOR select)
          K2 = rs12′ AND (rs22 XNOR select)
          .
          .
          .
          K62 = rs162′ AND (rs262 XNOR select)
          K63 = rs163′ AND (rs263 XNOR select)
First Stage Generate Equations
Gi = rs1i AND (rs2i XOR select)
for i = 0 . . . 63
Examples: G0 = rs10 AND (rs20 XOR select)
          G1 = rs11 AND (rs21 XOR select)
          G2 = rs12 AND (rs22 XOR select)
          .
          .
          .
          G62 = rs162 AND (rs262 XOR select)
          G63 = rs163 AND (rs263 XOR select)

TABLE 2A

Second Stage Propagate Equations

Basic Second Stage Propagate (P) Equation
Pi:j = Pi:m * P(m − 1):j (applied recursively)
Second Stage Propagate Equations
P3—0 = P3 P2 P1 P0
P7—4 = P7 P6 P5 P4
P11—8 = P11 P10 P9 P8
P15—12 = P15 P14 P13 P12
P19—16 = P19 P18 P17 P16
P23—20 = P23 P22 P21 P20
P27—24 = P27 P26 P25 P24
P31—28 = P31 P30 P29 P28
P35—32 = P35 P34 P33 P32
P39—36 = P39 P38 P37 P36
P43—40 = P43 P42 P41 P40
P47—44 = P47 P46 P45 P44
P51—48 = P51 P50 P49 P48
P55—52 = P55 P54 P53 P52
P59—56 = P59 P58 P57 P56
P63—60 = P63 P62 P61 P60

TABLE 2B

Second Stage Kill Equations

Basic Second Stage Kill (K) Equation
Ki:j = Ki:m + K(m − 1):j * Pi:m (applied recursively)
Second Stage Kill Equations
K3—0 = K3 + (K2 P3) + (K1 P3 P2) + (K0 P3 P2 P1)
K7—4 = K7 + (K6 P7) + (K5 P7 P6) + (K4 P7 P6 P5)
K11—8 = K11 + (K10 P11) + (K9 P11 P10) + (K8 P11 P10 P9)
K15—12 = K15 + (K14 P15) + (K13 P15 P14) + (K12 P15 P14 P13)
K19—16 = K19 + (K18 P19) + (K17 P19 P18) + (K16 P19 P18 P17)
K23—20 = K23 + (K22 P23) + (K21 P23 P22) + (K20 P23 P22 P21)
K27—24 = K27 + (K26 P27) + (K25 P27 P26) + (K24 P27 P26 P25)
K31—28 = K31 + (K30 P31) + (K29 P31 P30) + (K28 P31 P30 P29)
K35—32 = K35 + (K34 P35) + (K33 P35 P34) + (K32 P35 P34 P33)
K39—36 = K39 + (K38 P39) + (K37 P39 P38) + (K36 P39 P38 P37)
K43—40 = K43 + (K42 P43) + (K41 P43 P42) + (K40 P43 P42 P41)
K47—44 = K47 + (K46 P47) + (K45 P47 P46) + (K44 P47 P46 P45)
K51—48 = K51 + (K50 P51) + (K49 P51 P50) + (K48 P51 P50 P49)
K55—52 = K55 + (K54 P55) + (K53 P55 P54) + (K52 P55 P54 P53)
K59—56 = K59 + (K58 P59) + (K57 P59 P58) + (K56 P59 P58 P57)

TABLE 2C

Second Stage Generate Equations

Basic Second Stage Generate (G) Equation
Gi:j = Gi:m + G(m − 1)j * Pi:m (applied recursively)
Second Stage Generate Equations
G3—0 = G3 + (G2 P3) + (G1 P3 P2) + (G0 P3 P2 P1)
G7—4 = G7 + (G6 P7) + (G5 P7 P6) + (G4 P7 P6 P5)
G11—8 = G11 + (G10 P11) + (G9 P11 P10) + (G8 P11 P10 P9)
G15—12 = G15 + (G14 P15) + (G13 P15 P14) + (G12 P15 P14 P13)
G19—16 = G19 + (G18 P19) + (G17 P19 P18) + (G16 P19 P18 P17)
G23—20 = G23 + (G22 P23) + (G21 P23 P22) + (G20 P23 P22 P21)
G27—24 = G27 + (G26 P27) + (G25 P27 P26) + (G24 P27 P26 P25)
G31—28 = G31 + (G30 P31) + (G29 P31 P30) + (G28 P31 P30 P29)
G35—32 = G35 + (G34 P35) + (G33 P35 P34) + (G32 P35 P34 P33)
G39—36 = G39 + (G38 P39) + (G37 P39 P38) + (G36 P39 P38 P37)
G43—40 = G43 + (G42 P43) + (G41 P43 P42) + (G40 P43 P42 P41)
G47—44 = G47 + (G46 P47) + (G45 P47 P46) + (G44 P47 P46 P45)
G51—48 = G51 + (G50 P51) + (G49 P51 P50) + (G48 P51 P50 P49)
G55—52 = G55 + (G54 P55) + (G53 P55 P54) + (G52 P55 P54 P53)
G59—56 = G59 + (G58 P59) + (G57 P59 P58) + (G56 P59 P58 P57)
G63—60 = G63 + (G62 P63) + (G61 P63 P62) + (G60 P63 P62 P61)

TABLE 3A

Third Stage Propagate Equations

Basic Third Stage Propagate (P) Equation
Pi:j = Pi:m * P(m − 1):j (applied recursively)
Third Stage Propagate Equations
P15—0 = P15—12 P11—8 P7—4 P3—0
P19—4 = P19—16 P15 —12 P11—8 P7—4
P23—8 = P23—20 P19—16 P15—12 P11—8
P27—12 = P27—24 P23—20 P19—16 P15—12
P31—36 = P31—28 P27—24 P23—20 P19—16
P35—20 = P35—32 P31—28 P27—24 P23—20
P39—24 = P39—36 P35—32 P31—28 P27—24
P43—28 = P43—40 P39—36 P35—32 P31—28
P47—32 = P47—44 P43—40 P39—36 P35—32
P51—36 = P51—48 P47—44 P43—40 P39—36
P55—40 = P55—52 P51—48 P47—44 P43—40
P59—44 = P59—56 P55—52 P51—48 P47—44
P63—48 = P63—60 P59—56 P55—52 P51—48

TABLE 3B

Third Stage Kill Equations

Basic Third Stage Kill (K) Equation
Ki:j = Ki:m + K(m − 1):j * Pi:m (applied recursively)
Third Stage Kill Equations
K15—0 = K15—12 + (K11—8 P15—12) +(K7—4 P15—12 P11—8) +
(K3—0 P15—12 P11—8 P7—4)
K19—4 = K19—16 + (K15—12 P19—16) + (K11—8 P19—16 P15—12) +
(K7—4 P19—16 P15—12 P11—8)
K23—8 = K23—20 + (K19—16 P23—20) + (K15—12 P23—20 P19—16) +
(K11—8 P23—20 P19—16 P15—12)
K27—12 = K27—24 + (K23—20 P27—24) + (K19—16 P27—24 P23—20) +
(K15—12 P27—24 P23—20 P19—16)
K31—16 = K31—28 + (K27—24 P31—28) + (K23—20 P31—28 P27—24) +
(K19—16 P31—28 P27—24 P23—20)
K35—20 = K35—32 + (K31—28 P35—32) + (K27—24 P35—32 P31—28) +
(K23—20 P35—32 P31—28 P27—24)
K39—24 = K39—36 + (K35—32 P39—36) + (K31—28 P39—36 P35—32) +
(K27—24 P39—36 P35—32 P31—28)
K43—28 = K43—40 + (K39—36 P43—40) + (K35—32 P43—40 P39—36) +
(K31—28 P43—40 P39—36 P35—32)
K47—32 = K47—44 + (K43—40 P47—44) + (K39—36 P47—44 P43—40) +
(K35—32 P47—44 P43—40 P39—36)
K51—36 = K51—48 + (K47—44 P51—48) + (K43—40 P51—48 P47—44) +
(K39—36 P51—48 P47—44 P43—40 )
K55—40 = K55—52 + (K51—48 P55—52) + (K47—44 P55—52 P51—48) +
(K43—40 P55—52 P51—48 P47—44)
K59—44 = K59—56 + (K55—52 P59—56) + (K51—48 P59—56 P55—52) +
(K47—44 P59—56 P55—52 P51—48)
K63—48 = K63—60 + (K59—56 P63—60) + (K55—52 P63—60 P59—56) +
(K51—48 P63—60 P59—56 P55—52)

TABLE 3C

Third Stage Generate Equations

Basic Third Stage Generate (G) Equation
Gi:j = Gi:m + G(m − 1):j * Pi:m (applied recursively)
Third Stage Generate Equations
G15—0 = G15—12 + (G11—8 P15—12) + (G7—4 P15—12 P11—8) +
(G3—0 P15—12 P11—8 P7—4)
G19—4 = G19—16 + (G15—12 P19—16) + (G11—8 P19—16 P15—12) +
(G7—4 P19—16 P15—12 P11—8)
G23—8 = G23—20 + (G19—16 P23—20) + (G15—12 P23—20 P19—16) +
(G11—8 P23—20 P19—16 P15—12)
G27—12 = G27—24 + (G23—20 P27—24) + (G19—16 P27—24 P23—20) +
(G15—12 P27—24 P23—20 P19—16)
G31—16 = G31—28 + (G27—24 P31—28) + (G23—20 P31—28 P27—24) +
(G19—16 P31—28 P27—24 P23—20)
G35—20 = G35—32 + (G31—28 P35—32) + (G27—24 P35—32 P31—28) +
(G23—20 P35—32 P31—28 P27—24)
G39—24 = G39—36 + (G35—32 P39—36) + (G31—28 P39—36 P35—32) +
(G27—24 P39—36 P35—32 P31—28)
G43—28 = G43—40 + (G39—36 P43—40) + (G35—32 P43—40 P39—36) +
(G31—28 P43—40 P39—36 P35—32)
G47—32 = G47—44 + (G43—40 P47—44) + (G39—36 P47—44 P43—40) +
(G35—32 P47—44 P43—40 P39—36)
G51—36 = G51—48 + (G47—44 P51—48) + (G43—40 P51—48 P47—44) +
(G39—36 P51—48 P47—44 P43—40)
G55—40 = G55—52 + (G51—48 P55—52) + (G47—44 P55—52 P51—48) +
(G43—40 P55—52 P51—48 P47—44)
G59—44 = G59—56 + (G55—52 P59—56) + (G51—48 P59—56 P55—52) +
(G47—44 P59—56 P55—52 P51—48)
G63—48 = G63—60 + (G59—56 P63—60) + (G55—52 P63—60 P59—56) +
(G51—48 P63—60 P59—56 P55—52)

TABLE 4A

Fourth Stage Carry Equations

Basic Fourth Stage Carry (C) Equation
Ci = Gi + Ci − 1 * Pi (applied recursively)
Carry Equation for Each Fourth Bit Using Global Carry Chain
C3—0 = G3—0
C7—0 = G7—4 + (G3—0 P7—4)
C11—0 = G11—8 + (G7—4 P11—8) + (G3—0 P11—8 P7—4)
C15—0 = G15—0
C19—0 = G19—4 + (G3—0 P19—4)
C23—0 = G23—8 + (G7—4 P23—8) + (G3—0 P23—8 P7—4)
C27—0 = G27—12 + (G11—8 P27—12) + (G7—4 P27—12 P11—8) +
(G3—0 P27—12 P11—8 P7—4)
C31—0 = G31—16 + (G15—0 P31—16)
C35—0 = G35—20 + (G19—4 P35—20) + (G3—0 P35—20 P19—4)
C39—0 = G39—24 + (G23—8 P39—24) + (G7—4 P39—24 P23—8) +
(G3—0 P39—24 P23—8 P7—4)
C43—0 = G43—28 + (G27—12 P43—28) + (G11—8 P43—28 P27—12) +
(G7—4 P43—28 P27—12 P11—8) +
(G3—0 P43—28 P27—12 P11—8 P7—4)
C47—0 = G47—32 + (G31—16 P47—32) + (G15—0 P47—32 P31—16)
C51—0 = G51—36 + (G35—20 P51—36) + (G19—4 P51—36 P35—20) +
(G3—0 P51—36 P35—20 P19—4)
C55—0 = G55—40 + (G39—24 P55—40) + (G23—8 P55—40 P39—24) +
(G7—4 P55—40 P39—24 P23—8) +
(G3—0 P55—40 P39—24 P23—8 P7—4)
C59—0 = G59—44 + (G43—28 P59—44) + (G27—12 P59—44 P43—28) +
(G11—8 P59—44 P43—28 P27—12) + (G7—4 P59—44 P43—28 P27—12 P11—8) +
(G3—0 P59—44  P43—28 P27—12 P11—8 P7—4)
C63—0 = G63—48 + (G47—32 P63—48) + (G31—16 P63—48 P47—32 ) +
(G15—0 P63—48 P47—32 P31—16)

TABLE 4B

Fourth Stage Carry Complement Equations

Basic Fourth Stage Carry Complement (C′) Equation
C1′ = K1 + Ci − 1′ * Pi (applied recursively)
Carry Complement Equation for Each Fourth Bit Using Global
Carry Chain
C3—0′ = K3—0
C7—0′ = K7—4 + (K3—0 P7—4)
C11—0′ = K11—8 + (K7—4 P11—8) + (K3—0 P11—8 P7—4)
C15—0′ = K15—0
C19—0′ = K19—4 + (K3—0 P19—4)
C23—0′ = K23—8 + (K7—4 P23—8) + (K3—0 P23—8 P7—4)
C27—0′ = K27—12 + (K11—8 P27—12) + (K7—4 P27—12 P11—8) +
(K3—0 P27—12 P11—8 P7—4)
C31—0′ = K31—16 + (K15—0 P31—16)
C35—0′ = K35—20 + (K19—4 P35—20) + (K3—0 P35—20 P19—4)
C39—0′ = K39—24 + (K23—8 P39—24) + (K7—4 P39—24 P23—8) +
(K3—0 P39—24 P23—8 P7—4)
C43—0′ = K43—28 + (K27—12 P43—28) + (K11—8 P43—28 P27—12) +
(K7—4 P43—28 P27—12 P11—8) +
(K3—0 P43—28 P27—12 P11—8 P7—4)
C47—0′ = K47—32 + (K31—16 P47—32 ) + (K15—0 P47—32 P31—16)
C51—0′ = K51—36 + (K35—20 P51—36) + (K19—4 P51—36 P35—20) +
(K3—0 P51—36 P35—20 P19—4)
C55—0′ = K55—40 + (K39—24 P55—40) + (K23—8 P55—40 P39—24) +
(K7—4 P55—40 P39—24 P23—8) +
(K3—0 P55—40 P39—24 P23—8 P7—4)
C59—0′ = K59—44 + (K43—28 P59—44) + (K27—12 P59—44 P43—28) +
(K11—8 P59—44 P43—28 P27—12) + (K7—4 P59—44 P43—28 P27—12 P11—8) +
(K3—P59—44P43—28 P27—12 P11—8 P7—4)
C63—0′ = K63—48 + (K47—32 P63—48) + (K31—16 P63—48 P47—32) +
(K15—0 P63—48 P47—32 P31—16)

TABLE 5

Local Sum Equations
Four-bit Local Sum (Z) Equations


Zi = Pi XOR Cin
Zi + 1 = Pi + 1 XOR (Gi + Pi Cin)
Zi + 2 = Pi + 2 XOR (Gi + 1 + Pi + 1 Gi + Pi Pi + 1 Cin)
Zi + 3 = Pi + 3 XOR (Gi + 2 + Pi + 2 Gi + 1 +
Pi + 2 Pi +1 Gi + Pi Pi + 1 Pi + 2 Cin)
Cin = 1 for Zi, Zi + 1, Zi + 2, and Zi + 3
Cin = 0 for Zi′, Zi + 1′, Zi + 2′, and Zi + 3′
i = {0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 48, 52, 56, 60}

While this invention has been described in terms of several embodiments, it will be appreciated that those skilled in the art upon reading the preceding specifications and studying the drawings will realize various alterations, additions, permutations and equivalents thereof. It is therefore intended that the present invention includes all such alterations, additions, permutations, and equivalents as fall within the true spirit and scope of the invention.

Claims

1. arithmetic logic processing circuitry, comprising:

a global carry chain implementing static propagate, kill, and generate circuitry, including,

a first stage for generating first propagate, kill, and generate signals for each bit of a pair of multi-bit signal vectors;

a second stage for generating second propagate, kill, and generate signals for a first group of the first propagate, kill, and generate signals;

a third stage for generating third propagate, kill, and generate signals for a first group of the second propagate, kill, and generate signals; and

a fourth stage for generating carry signals and carry complement signals, the fourth stage receiving inputs from each of the second stage and the third stage, the carry signals and the carry complement signals being useful for generating a sum result.

2. arithmetic logic processing circuitry as recited in claim 1, wherein the second stage generates second propagate, kill, and generate signals for a plurality of groups of the first propagate, kill, and generate signals, the plurality of groups includes the first group of the first propagate, kill, and generate signals.

3. arithmetic logic processing circuitry as recited in claim 2, wherein each of the plurality of groups of the first propagate, kill, and generate signals corresponds to a group of four bits of the pair of multi-bit signal vectors.

4. arithmetic logic processing circuitry as recited in claim 1, wherein the third stage generates third propagate, kill, and generate signals for a plurality of groups of the second propagate, kill, and generate signals, the plurality of groups includes the first group of the second propagate, kill, and generate signals.

5. arithmetic logic processing circuitry as recited in claim 4, wherein each group of the plurality of groups includes a number of successive second propagate, kill, and generate signals, the first group defined by the number of successive second propagate, kill, and generate signals, and groups after the first group defined by the number of successive second propagate, kill, and generate signals, wherein a first of the number of successive second propagate, kill, and generate signals within each group after the first group is a second of the number of successive second propagate, kill, and generate signals in an immediately preceding group.

6. arithmetic logic processing circuitry as recited in claim 5, wherein each group of the plurality of groups includes four successive second propagate, kill, and generate signals.

7. arithmetic logic processing circuitry as recited in claim 1, wherein the fourth stage is configured to generate carry signals and carry complement signals for each fourth bit in the pair of multi-bit signal vectors, wherein each of the carry signals and carry complement signals propagate from a bit-zero in the pair of multi-bit signal vectors.

8. arithmetic logic processing circuitry as recited in claim 1, further comprising:

a summation processing circuit for receiving the first propagate, kill, and generate signals from the first stage, the first propagate, kill, and generate signals being processed to create sum and sum complement signals for each bit represented by the first propagate, kill, and generate signals, the summation processing circuit further being configured to fold the sum and sum complement signals with the carry signals to produce a final sum output signal vector.

9. arithmetic logic processing circuitry as recited in claim 8, wherein the summation processing circuit is configured to create sum and sum complement signals for a plurality of groups of four bits, wherein the plurality of groups of four bits include each bit represented by the first propagate, kill, and generate signals.

10. arithmetic logic processing circuitry as recited in claim 9, wherein the fourth stage is configured to generate carry signals for each fourth bit in the pair of multi-bit signal vectors, wherein each of the carry signals propagate from a bit-zero in the pair of multi-bit signal vectors, the summation processing circuit being configured to fold the carry signals for each fourth bit with the sum and sum complement signals for a corresponding group of four bits within the plurality of groups of four bits.

11. arithmetic logic processing circuitry as recited in claim 1, wherein the first stage is configured to receive a subtraction select signal, the first stage being configured to use the subtraction select signal to invert each bit of a second multi-bit signal vector within the pair of multi-bit signal vectors, wherein inversion of each bit of the second multi-bit signal vector causes the sum result to represent a subtraction result.

12. arithmetic logic processing circuitry as recited in claim 1, wherein the global carry chain implementing static propagate, kill, and generate circuitry is further configured to implement push-pull circuitry at locations where a pair of signals are mutually exclusive, the push-pull circuitry being configured to use a first signal in the pair of signals to control refresh circuitry configured to refresh a second signal in the pair of signals.

13. arithmetic logic processing circuitry as recited in claim 12, wherein the first signal is a low signal, the refresh circuitry is a PMOS device, and the second signal is a high signal.

14. A method for making arithmetic logic processing circuitry, comprising:

implementing a global carry chain using static propagate, kill, and generate circuitry, including,

implementing a first stage for generating first propagate, kill, and generate signals for each bit of a pair of multi-bit signal vectors;

implementing a second stage for generating second propagate, kill, and generate signals for a first group of the first propagate, kill, and generate signals;

implementing a third stage for generating third propagate, kill, and generate signals for a first group of the second propagate, kill, and generate signals; and

implementing a fourth stage for generating carry signals and carry complement signals, the fourth stage receiving inputs from each of the second stage and the third stage, the carry signals and the carry complement signals being useful for generating a sum result.

15. A method for making arithmetic logic processing circuitry as recited in claim 14, wherein implementing the second stage generates second propagate, kill, and generate signals for a plurality of groups of the first propagate, kill, and generate signals, the plurality of groups including the first group of the first propagate, kill, and generate signals.

16. A method for making arithmetic logic processing circuitry as recited in claim 15, wherein each of the plurality of groups of the first propagate, kill, and generate signals corresponds to a group of four bits of the pair of multi-bit signal vectors.

17. A method for making arithmetic logic processing circuitry as recited in claim 14, wherein implementing the third stage generates third propagate, kill, and generate signals for a plurality of groups of the second propagate, kill, and generate signals, the plurality of groups including the first group of the second propagate, kill, and generate signals.

18. A method for making arithmetic logic processing circuitry as recited in claim 17, wherein each group of the plurality of groups includes a number of successive second propagate, kill, and generate signals, the first group defined by the number of successive second propagate, kill, and generate signals, and groups after the first group defined by the number of successive second propagate, kill, and generate signals, wherein a first of the number of successive second propagate, kill, and generate signals within each group after the first group is a second of the number of successive second propagate, kill, and generate signals in an immediately preceding group.

19. A method for making arithmetic logic processing circuitry as recited in claim 18, wherein each group of the plurality of groups includes four successive second propagate, kill, and generate signals.

20. A method for making arithmetic logic processing circuitry as recited in claim 14, wherein implementing the fourth stage is performed to generate carry signals and carry complement signals for each fourth bit in the pair of multi-bit signal vectors, wherein each of the carry signals and carry complement signals propagate from a bit-zero in the pair of multi-bit signal vectors.

21. A method for making arithmetic logic processing circuitry as recited in claim 14, further comprising:

implementing a summation processing circuit for receiving the first propagate, kill, and generate signals from the first stage, the first propagate, kill, and generate signals being processed to create sum and sum complement signals for each bit represented by the first propagate, kill, and generate signals, the summation processing circuit being further implemented to fold the sum and sum complement signals with the carry signals to produce a final sum output signal vector.

22. A method for making arithmetic logic processing circuitry as recited in claim 21, wherein implementing the summation processing circuit is performed to create sum and sum complement signals for a plurality of groups of four bits, wherein the plurality of groups of four bits include each bit represented by the first propagate, kill, and generate signals.

23. A method for making arithmetic logic processing circuitry as recited in claim 22, wherein implementing the fourth stage is performed to generate carry signals for each fourth bit in the pair of multi-bit signal vectors, wherein each of the carry signals propagate from a bit-zero in the pair of multi-bit signal vectors, the summation processing circuit being further implemented to fold the carry signals for each fourth bit with the sum and sum complement signals for a corresponding group of four bits within the plurality of groups of four bits.

24. A method for making arithmetic logic processing circuitry as recited in claim 14, wherein implementing the first stage is performed to receive a subtraction select signal, implementing the first stage being performed to use the subtraction select signal to invert each bit of a second multi-bit signal vector within the pair of multi-bit signal vectors, wherein inversion of each bit of the second multi-bit signal vector causes the sum result to represent a subtraction result.

25. A method for making arithmetic logic processing circuitry as recited in claim 14, wherein implementing the global carry chain using static propagate, kill, and generate circuitry is further performed by implementing push-pull circuitry at locations where a pair of signals are mutually exclusive, the push-pull circuitry being implemented to use a first signal in the pair of signals to control refresh circuitry configured to refresh a second signal in the pair of signals.

26. A method for making arithmetic logic processing circuitry as recited in claim 25, wherein the first signal is a low signal, the refresh circuitry is a PMOS device, and the second signal is a high signal.

27. arithmetic logic unit circuitry, comprising:

a four-stage global carry chain implementing static propagate, kill, and generate circuitry for generating carry signals associated with a pair of multi-bit signal vectors, the carry signals being useful for generating a sum result for the pair of multi-bit signal vectors, wherein the carry signals include intermediate fourth-bit carry signals; and

a summation processing circuit for creating sum and sum complement signals for each bit in the pair of multi-bit signal vectors, the summation processing circuit configured to generate local fourth-bit sum and sum complement signals, the summation processing circuit further configured to fold the local fourth-bit sum and sum complement signals with the intermediate fourth-bit carry signals to produce a final sum output signal vector.

28. arithmetic logic unit circuitry as recited in claim 27, wherein the four-stage global carry chain comprises:

a first stage for generating first propagate, kill, and generate signals for each bit of the pair of multi-bit signal vectors;

a second stage for generating second propagate, kill, and generate signals for a first group of the first propagate, kill, and generate signals;

a third stage for generating third propagate, kill, and generate signals for a first group of the second propagate, kill, and generate signals; and

a fourth stage for generating carry signals and carry complement signals, the fourth stage receiving inputs from each of the second stage and the third stage, the carry signals and the carry complement signals being useful for generating the sum result.

29. arithmetic logic unit circuitry as recited in claim 28, wherein the second stage generates second propagate, kill, and generate signals for a plurality of groups of the first propagate, kill, and generate signals, the plurality of groups includes the first group of the first propagate, kill, and generate signals.

30. arithmetic logic unit circuitry as recited in claim 29, wherein each of the plurality of groups of the first propagate, kill, and generate signals corresponds to a group of four bits of the pair of multi-bit signal vectors.

31. arithmetic logic unit circuitry as recited in claim 28, wherein the third stage generates third propagate, kill, and generate signals for a plurality of groups of the second propagate, kill, and generate signals, the plurality of groups includes the first group of the second propagate, kill, and generate signals.

32. arithmetic logic unit circuitry as recited in claim 31, wherein each group of the plurality of groups includes a number of successive second propagate, kill, and generate signals, the first group defined by the number of successive second propagate, kill, and generate signals, and groups after the first group defined by the number of successive second propagate, kill, and generate signals, wherein a first of the number of successive second propagate, kill, and generate signals within each group after the first group is a second of the number of successive second propagate, kill, and generate signals in an immediately preceding group.

33. arithmetic logic unit circuitry as recited in claim 32, wherein each group of the plurality of groups includes four successive second propagate, kill, and generate signals.

34. arithmetic logic unit circuitry as recited in claim 28, wherein the fourth stage is configured to generate carry signals and carry complement signals for each fourth bit in the pair of multi-bit signal vectors, wherein each of the carry signals and carry complement signals propagate from a bit-zero in the pair of multi-bit signal vectors.

35. arithmetic logic unit circuitry as recited in claim 28, wherein the summation processing circuit is configured to receive the first propagate, kill, and generate signals from the first stage, the first propagate, kill, and generate signals being processed to create sum and sum complement signals for each bit represented by the first propagate, kill, and generate signals.

36. arithmetic logic unit circuitry as recited in claim 28, wherein the summation processing circuit is configured to create sum and sum complement signals for a plurality of groups of four bits, wherein the plurality of groups of four bits include each bit represented by the first propagate, kill, and generate signals.

37. arithmetic logic unit circuitry as recited in claim 36, wherein the fourth stage is configured to generate carry signals for each fourth bit in the pair of multi-bit signal vectors, wherein each of the carry signals propagate from a bit-zero in the pair of multi-bit signal vectors, the summation processing circuit being configured to fold the carry signals for each fourth bit with the sum and sum complement signals for a corresponding group of four bits within the plurality of groups of four bits.

38. arithmetic logic unit circuitry as recited in claim 28, wherein the first stage is configured to receive a subtraction select signal, the first stage being configured to use the subtraction select signal to invert each bit of a second multi-bit signal vector within the pair of multi-bit signal vectors, wherein inversion of each bit of the second multi-bit signal vector causes the sum result to represent a subtraction result.

39. arithmetic logic unit circuitry as recited in claim 27, wherein the four-stage global carry chain implementing static propagate, kill, and generate circuitry is further configured to implement push-pull circuitry at locations where a pair of signals are mutually exclusive, the push-pull circuitry being configured to use a first signal in the pair of signals to control refresh circuitry configured to refresh a second signal in the pair of signals.

40. arithmetic logic unit circuitry as recited in claim 39, wherein the first signal is a low signal, the refresh circuitry is a PMOS device, and the second signal is a high signal.