Patent Application
20090100390
Although digital circuits are typically constructed to accept data input—and provide data output—in a form that often appears to be analog or base ten, the circuits themselves operate in a binary domain. Thus, operations that appear relatively simple in base ten, often require many steps to be performed in binary. Although these steps are not complex in operation, they can easily grow to tens, hundreds, or thousands of individual steps that must be performed in order to implement the desired calculation. In a dedicated circuit, each of these individual steps requires a set of gates that must be fabricated in the integrated circuit.
As the term is used herein, “integrated circuit” includes devices such as those formed on monolithic semiconducting substrates, such as those formed of group IV materials like silicon or germanium, or group III-V compounds like gallium arsenide, or mixtures of such materials. The term includes all types of devices formed, such as memory and logic, and all designs of such devices, such as MOS and bipolar. The term also comprehends applications such as flat panel displays, solar cells, and charge coupled devices.
Thus, a good circuit design (in this context) is one that will generally reduce the number of gates that is required for a given calculation or reduce the number of stages of gates that is required for the calculation. This latter improvement is referred to as reducing the depth of the circuit, and it relates to the delay that is produced by the circuit. The greater the number of stages required by the circuit, the greater the circuit delay. Thus, good circuit designs not only require less space within the integrated circuit—because fewer gates are required—but also tend to produce results in a lesser period of time—because fewer stages are required (smaller depth). Thus, reducing at least one of the number of gates and the depth to perform a given calculation is highly desirable.
Examples of integrated circuits that tend to require a relatively large number of stages include adders, comparators, and counters of leading and trailing zeros and ones. When binary numbers having many digits are to be manipulated in this manner, a cascading series of gate circuits are typically employed. Circuit designs that reduce the depth of the circuit also tend to generally reduce the gate count of the circuit, thereby reducing the size of the circuit, the memory capacity required by the circuit, and the time required to implement the calculation.
Many different methods have been devised to efficiently design such circuits under various constraints and with different optimization goals. For example, the “straightforward” method of a ripple carry adder produces a circuit that is extremely small in size, but with a depth of O(n), where n is the number of digits in the input binary numbers. Carry look-ahead adder, carry bypass adder, and carry select adder circuits contain more gates, but they are much faster. The best implementations have a depth of about 2 log2n. (Here and everywhere below, the depth is defined as the maximum number of two-input gates along paths from a circuit's inputs to its outputs, if the circuit cannot contain gates with more than two inputs). Khrapchenko developed a method in 1967 that produced circuits with a depth of log2n+const×√ log2n, but his method was efficient only for huge values of n. Others have produced methods with a depth of not more than 1.441 log2n+const (in 2001) and 1.262 log2n+const (in 2003), both with very small constant additive terms. Thus, even seemingly-small improvements can be very important in reducing the space and time required by such a circuit.
What is needed, therefore, is a method that overcomes issues such as those described above, at least in part.
The above and other needs are met by a method of designing a logic circuit based on one of the functions of the form fn=x1 (x2 & (x3
(x4 & . . . xn . . . ))) and fn=x1 & (x2
(x3 & (x4
. . . xn . . . ))), by (a) selecting n as the number of variables of the logic circuit, (b) testing n against a threshold, (c) for values of n less than the threshold, using a first algorithm to design the logic circuit, and (d) for values of n greater than the threshold, using a second algorithm to design the logic circuit.
Further advantages of the invention are apparent by reference to the detailed description when considered in conjunction with the figures, which are not to scale so as to more clearly show the details, wherein like reference numbers indicate like elements throughout the several views, and wherein:
The depth, and therefore the delay, of numerous important datapath operators (adders, comparators, counters of leading and trailing zeros and ones, etc.) is almost entirely defined by the implementation of functions of the form fn=x1 (x2 & (x3
(x4 & . . . xn . . . ))) or fn=x1 & (x2
(x3 & (x4
. . . xn . . . ))), where
is a logical OR function, and & is a logical AND function. There is described herein a new heuristic to generate low-depth circuit implementations of these functions. More precisely, the goal is to minimize maximal numbers of two-input (N)AND/(N)OR gates that are disposed along paths from inputs of the circuit to its outputs, provided that negations (NOT) are not counted and that no other gate types (such as XOR/XNOR gates and multi-input gates) are permitted. Using this method, there were found many optimal depth circuits. In this description, there are shown circuits with a depth of six for n=33, a depth of seven for n=60, a depth of eight for n=109, a depth of nine for n=202, and a depth of ten for n=375. These results produce a lower depth than all previously published methods.
Let us consider addition of two binary numbers. If we write it as
then si=ai {circle around (+)} bi {circle around (+)} ci+1 (for i>0), where {circle around (+)} means XOR (addition modulo 2), and ci is the i-th carry bit; also s0=c1.
When ci=1?
Let xi mean (ai=1 & bi=1), and let yi mean (ai=1 bi=1). Using this notation, we can write:
That is, the upper bound of the depth of an n-bit adder can be estimated as:
depth(f2n−1)+max(depth(), depth(&))+depth({circle around (+)});
Note that the last two terms do not depend on n and are small (in our model, depth()=depth(&)=1 and depth({circle around (+)})=2).
If A and B are written as (a1, a2, a3, . . . , an) and (b1, b2, b3 . . . , bn), where index 1 corresponds to the most significant bit, then “A>B” is true in the following cases:
(Note that we can use “≧” instead of “=” without changing the result. The only difference is that cases with “≧” are not mutually exclusive.)
Let xi mean ai>bi, and let yi mean either ai=bi or ai≧bi (in other words, yi can have any value in the case of ai>bi)
Then A>B can be expressed as:
x
1
(y1 & (x2
(y2 & . . . & (xn−1
(yn−1 & xn)) . . . )))=f2n−1(x1, y1, x2, y2, . . . , xn−1, yn−1, xn).
Thus, the depth of the n-bit comparison “A is greater than B” (and, obviously, “less than”) has an upper bound of the form:
depth(f2n−1)+max(depth(>), depth(≧));
where both one-bit operations “>” and “≧” have a depth of one. Comparison for “greater than or equal to” is almost the same, because it is just a complement (which is free in our model) of “less than.”
All four variants of such a counting operation are essentially identical, and thus we'll analyze only a counting operation of leading ones in the binary vector A=(a1, a2, a3, . . . , an). Let's start with the least significant bit in the number of leading ones, or, in other words, let's find whether it is odd or even. It is even in the following cases:
Let xi (i=1, 2, 3, . . . ) mean “a2i−1=0”, and let yi mean “a2i−1=a2i=1”, i.e. xi=a2i−1 and yi=(a2i−1 & a2i). Then the set of above-mentioned conditions can be rewritten as:
x
1
(y1 & (x2
(y2 & . . . & (x(n−1)/2
(y(n−1)/2 & x(n+1)/2n)) . . . )))=fn(x1, y1, x2, y2, . . . , x(n−1)/2, y(n−1)/2, x(n+1)/2)
if n is an odd number, or if n is an even number:
x
1
(y1 & (x2
(y2 & . . . & (xn/2
yn/2) . . . )))=fn(x1, y1, x2, y2, . . . , xn/2, yn/2)
The second least significant bit in the number of leading ones can be expressed in a similar way as f[n/2](x′1, y′1, x′2, y′2, . . . ), where x′i=y2i−1 and y′i=(y2i−1 & y2i); then the third least significant bit can be expressed in a similar way as f[n/4](x″1, y″1, x″2, y″2 . . . ), where x″i=
y′2i−1 and y″i=(y′2i−1 & y′2i).
Overview of Depth-Efficient Implementations of fn
The present method is based on an automated search of solutions in a special class of circuits; it is much faster than a full search among all possible circuits, but probably gives the best possible circuits or at least very good circuits (because it covers all other known methods). Calculations up to n=2,000,000 inputs have been accomplished (probably covering all practical needs) and a table of values of depth(fn) prepared. New circuits produced in this manner are never worse (in terms of the depths) than any previously known ones, and in some cases they eventually supersede the older circuit designs, such as at:
30<n<34,
57<n<61,
91<n<110,
172<n<203,
273<n<376,
516<n<699,
820<n<1312,
1549<n<4646, and
for all n>4647.
Under the following conditions, prior-published results are also superseded:
327<n<376,
606<n<699,
982<n<1312,
1819<n<2467,
2946<n<4546,
5457<n<8783, and
for all n>8839.
The table below compares some prior art methods with the present method. For each depth d, the numbers in the table show the maximum n such that n-input circuits produced by a particular method have a depth d or less; values shown in italics are the result of extrapolation. Thus, larger numbers in the table below represent larger numbers of n for a given depth, and therefore represent better designs.
Thus, the present method provides an improved design for all investigated depths. In graphical form, the behavior of these methods is shown in
Examples of the new circuits for fn and f′n with n=33, n=60, n=109, n=202 and n=375 are described below in detail. In addition, circuits for n=33, n=60 and n=109 are shown in
The methods used to generate the circuits are described below. There are three algorithms that are used in the method, designated below as algorithms A, B, and C.
Algorithm A gives the exact solution (a minimum depth circuit under the above-specified restrictions). However, its runtime and memory requirements grow exponentially with N (memory is proportional to 2N, time to more than 4N), so it can only be used for values of N up to about twenty or thirty. Algorithm A is described in greater detail than B and C, because B and C are heuristic optimizations of algorithm A, with possible loss of accuracy, but with huge improvements in performance. It should be noted that algorithm A itself is not destined for practical circuit design. Instead, it plays an auxiliary role, serving as an “etalon” to demonstrate that a certain version of algorithm B produces results of expected quality.
Algorithm B is based on the observation that, among minimum depth circuits that can be found by algorithm A, there are such circuits where the function that is computed on each net satisfies extra limitations. Thus, the search is reduced only to those circuits that exhibit this special property. This reduces time and memory from exponential growth to polynomial growth (where memory is proportional to N3, and time is about N6+ε). This method can be accomplished within a reasonable time for values of N up to about five hundred or one thousand.
Algorithm C is a further improvement based on an additional series of observations. It requires memory of a size equal to about N1+ε, and a computation time of about N2+ε, and can be accomplished within a reasonable time for values of N up to about one million.
The input of the algorithm is the value N, and the output of the algorithm is a circuit for f_N (the circuit for f′_N is the same with replacing all AND's with OR's, and vice-versa). The internal variables include:
In the description provided herein, decimal numbers are written without any additional notation, and binary numbers start with “#” (i.e. #1010=10 etc.), and have N+1 bits.
Function fN (as well as f′N) is a monotone Boolean function. Boolean function f is monotone if conditions x1≦y1, . . . ,xN≦yN lead to f(x1, . . . ,xN)≦f(y1, . . . , yN). Each monotone Boolean function has so called “upper zeros” and “lower units.” Vector argument (x1, . . . ,xN) is an upper zero of monotone Boolean function f, if f(x1, . . . ,xN)=0 and f(y1, . . . ,yN)=1 for each (y1, . . . ,yN) such that x1≦y1, . . . ,xN≦yN and at least one inequality is “<”. Similarly, vector argument (x1, . . . ,xN) is a lower unit of monotone Boolean function f, if f(x1, . . . ,xN)=1 and f(y1, . . . ,yN)=0 for each (y1, . . . ,yN) such that y1≦x1, . . . ,yN≦xN and at least one inequality is “<”. Monotone Boolean functions are fully defined by their upper zeros and lower units: in other words, if f and g are monotone Boolean functions, and f(x1, . . . ,xN)=g(x1, . . . ,xN) for all (x1, . . . ,xN) that are upper zeros of f or lower units of f, then f=g. Therefore, if a circuit built from AND and OR gates correctly computes a given monotone function f on all its upper zeros and lower ones, then it computes f everywhere.
All upper zeros and lower units of the present function fN are listed here (these are N+1 vectors of size N bits):
v1=0111111111 . . . (upper 0)
v2=1100000000 . . . (lower 1)
v3=1001111111 . . . (upper 0)
v4=1011000000 . . . (lower 1)
v5=1010011111 . . . (upper 0)
v6=1010110000 . . . (lower 1)
v7=1010100111 . . . (upper 0)
v8=1010101100 . . . (lower 1)
The last vector v(N+1) is either an upper zero 101010 . . . 1010 or a lower unit 101010 . . . 0101, depending on the parity of N.
Let (N+1)-bit vector of values (f(v1), . . . ,f(v(N+1))) be called a passport of function of f. Our fN has passport (010101 . . . ), and (from the above) there is no other monotone Boolean function with the same passport. Variables x1, . . . ,xN are monotone functions themselves, and they have passports:
(0111111111 . . . )
(1100000000 . . . )
(1001111111 . . . )
(1011000000 . . . )
(1010011111 . . . )
(1010110000 . . . )
(1010100111 . . . )
(1010101100 . . . )
The last passport is either (1010 . . . 101001) or (1010 . . . 010110), depending on the parity of N. Passports of functions are used as indices of arrays in the algorithm, and in the initialization phase, the depth of each input variable is declared to be zero. Note that logical operations on functions directly correspond to bitwise operations on their passports. For example, if f(x1, . . . ,xN)=g(x1, . . . ,xN)&h(x1, . . . ,xN) for all (x1, . . . ,xN), then passport(f)=passport(g) & passport(h). The same is true for “|” instead of “&”.
Then we are searching functions f of depth one. They are either f=g&h or f=g|h where g and h have a depth of zero. For example, let passports of f, g, and h be specified as k, i, and j, respectively. If depth[i]=0 and depth[j]=0, then depth[k] cannot be larger than one.
Next we search for functions f that have a depth of two. Again, they are either f=g&h or f=g|h, where g and h have a depth of zero or one, and at least one of g and h has a depth of one (using symmetry, we may specify that it is g that has a depth of one). That is, if depth[i]=1 and depth[j]≦1, then depth[k] cannot be larger than two.
Similarly, we continue the process described above for depths of 3, 4, 5, and so forth, until there is encountered a function that has a passport of (010101 . . . ), which is f_N. During these computations, we preserve the implementation (for each f, we save passports of g and h as well as the operation, “&” or “|”).
The final stage is just a printout of the expansion of fN, starting from fN. In the array print_code, we keep information about subfunctions that have yet to be printed (ACTIVE), are already printed (DONE), and are not yet used (PASSIVE). For each ACTIVE function, we print one level of expansion, change ACTIVE to DONE, and mark subfunctions as ACTIVE if they were PASSIVE (if they are already ACTIVE or DONE, we do nothing, avoiding printing their expansions twice).
A randomized version of Algorithm A can be defined by replacing the two steps “if(depth[k]>d)” with “if(depth[k]>d∥(depth[k]==d && RND( ))),” where RND( ) is a function that returns a random one-bit value. In this manner, if an alternative method to compute a subfunction with the same depth is discovered, then a random decision is made to select between the old and new expansions.
This algorithm is based on a certain observation in regard to the passports. A finite length binary sequence is defined as being “1-good” if it has a form of 0000 . . . , 1111 . . . , 0101 . . . or 1010 . . . . Further, a finite length binary sequence is defined as being “n-good” if it is a concatenation of n 1-good segments. For example, binary sequence 10101100000 is 3-good (also 4-good, 5-good etc.) because it can be split into three 1-good segments as 10101-1-00000 (or 1010-11-00000, or 10101-10-0000). Let us define “n-restricted Algorithm B” (where n≧3) as the following modification of Algorithm A: in all arrays, we will use only those elements that have n-good binary expansions. That is, instead of a loop like:
for(i=0; i<NN; i++)
we will use:
In addition, we replace the condition if (depth [k]>d) with if (k is n-good) if (depth [k]>d). That is, the n-restricted algorithm operates with the circuits such that passports of all subfunctions are n-good.
It is possible to implement an n-restricted algorithm B with a memory having a size of O(Nn−1)—if, instead of plain arrays, a data structure corresponding to n-good indices only is used. In this case, the required time drops to O(N2n−2+ε).
For practical usage, a four-restricted algorithm B has been chosen, due to the following two experimental observations. On the one hand, for all small N (here “small” means “small enough to run through the Algorithm A”), four-restricted Algorithm B finds the same depth as Algorithm A does. On the other hand, for larger N, five-restricted and six-restricted etc. algorithms B find the same depth as four-restricted algorithm B does.
The four-restricted Algorithm B (the implementation optimized as described above) works in an acceptable amount of memory and an acceptable length of time for values of N up to about one thousand, which covers most practical needs. Larger values of N require yet another level of optimization, explained below as Algorithm C.
A randomized version of algorithm B can also be developed, using the step substitutions as described above in regard to the randomized version of algorithm A.
Example (Implementation of f33 and Passports)
In this description, inputs are indexed as x0 . . . x32, not x1 . . . x33. Names of the functions are given as “letter+index+optional modifier,” where: “letter” is associated with the depth (0:x, 1:u, 2:v, 3:p, 4:q, 5:r, 6:f), “index” corresponds to the first input xi used in the subfunction, and “optional modifiers” (a and b) distinguish between different subfunctions with the same depth and index, like p0/p0a/p0b.
The inputs of the function are:
Yielding subfunctions of depth 1 as:
Subfunctions of depth 2 are:
Subfunctions of depth 3 are:
Subfunctions of depth 4 are:
Subfunctions of depth 5 are:
and the final function, having a depth of 6 is:
As can be seen, all these passports are four-good and have the form of either:
. . . xyxyyyy . . . yyyxyxyxy . . . xyxyxyyyyyy . . .
or:
. . . xyxyyyy . . . yyyxyxyxy . . . xyxyxxxxxxx . . .
These special passports can be encoded by the four-tuples (a,b,c,d), where a+b+c+d=N+1, and nonnegative integers a,b,c,d represent lengths of four parts:
(a) Alternating 0/1 starting from 1 (as if the zone were continuing prefix 10).
(b) Repeating last constant.
(c) Alternating 0/1.
(d) Repeating last constant.
On the boundary between zones (line . . . xyxyxxxx . . . ) we will resolve the ambiguity in the connection point to the favor of zone with alternating 0/1. Adding these “packed passports” to the functions listed above, with the following inputs:
Yields the following subfunctions having a depth of 1:
Subfunctions of depth 2 are:
Subfunctions with a depth of 3 are:
Subfunctions of depth 4 are:
Subfunctions of depth 5 are:
and the final function, having a depth of 6 is:
Note that the second element of these packed passports is always an even number.
In this discussion, pp(f) represents a packed passport of function f. Further, if P=(a,b,c,d) is a packed passport and t is an integer number, then shift_t(P) is defined as (a+t,b,c,d−t). Algorithm C is based on the observation that if P=pp(f), P′=pp(f′) where P′=shift_t(P), and f is expanded as f=g op h (here “op” is either “&” or “|”), then one of the functions f′ with P′=pp(f′) can be expanded as f′=g′ op′ h′, where pp(g′)=shift_t(pp(g)), pp(h′)=shift_t(pp(h)), and op′ is the same as op if t is even, and different from op otherwise.
For example (see above):
Therefore, we expect that p25=v25|v28 (op′=op because 14 is an even number), and we actually have this equation.
The nature of this effect is, if we have a circuit with inputs indexed il . . . ik, then adding t to all these indices and replacing (for t even) ANDs with ORs and vice-versa will produce the function with the passport shifted by t. The second observation is even simpler: if g and h are such that pp(g)=(x, . . . ) and pp(h)=(y, . . . ), then pp(g op h)=(min(x,y), . . . ) (provided that pp(g op h) exists, of course).
The third observation is based on the properties of monotone Boolean functions, as next described. Let g and h be two functions with passports (g1 . . . gN+1) and (h1 . . . hN+1), respectively. Let f be a function with passport (f1 . . . fN+1) equal to (0101 . . . ). We'll say that g is “not worse” than h if each gi is either hi or fi. Let S be a circuit built from AND and OR gates, computing f such that one of the subfunctions is h. Then, replacement of the gate computing h by a circuit computing g (i.e. function not worse than h) will not destroy the whole circuit: it will still compute f.
In terms of packed passports, the third observation can be used in the following form: if pp(g)=(a,b,c,d) and pp(h)=(a,b,c+t,d−t), where t is a nonnegative even integer, then h is not worse than g. Taking into account all three observations, we can say that it is enough to keep traces (for any given depth D and for a given b) only to the value c=c(b,D) which is maximum among all c such that functions with passport (0,b,c,N+1−b−c) have a depth that is not more than D.
A similar comparison can be made for parameter b: (a−t,b+t,c,d) is better than (a,b,c,d) if t is positive even number. Computation of these c(b,D) (for D=0, 1, 2, . . . and for each b) we give in terms of sets S(D) of pairs <b, c>. The input of the algorithm C is the number N. The algorithm uses “sets of pairs,” where each element of these sets has an additional field “history.”
Here the operation “add_to” must keep the set containing only the best elements. In other words: (A) if we are adding pair (xx,yy) and the set contains (x,y) such that y=yy (mod 2), x≧xx and y≧yy, then (xx,yy) will not be added (because the new pair is worse than one of the already existing pairs), and (B) if we are adding pair (xx,yy) and the set contains (x,y) such that y=yy (mod 2), x≦xx and y≦yy, then (x,y) will be removed (because the new pair is better than this old existing pair)
This algorithm C includes only a few of the possible combinations of passports. It may, therefore, cause some loss of quality in the produced circuits, but even in this form, it is efficient enough to outperform all currently existing alternatives. The experimental results of calculation (provided in the table above) lead us to the hypothesis that the depth of N-input functions fN and f′N is log2N+log2log2N+err(N), where err(N) is limited by a small constant. All existing alternatives are either const×log2N with const>1 or log2N+O(√ log2 N).
Algorithm C produces an output such as given below (for a sample run of N=33; long lines are wrapped):
This text can be traced back to produce a netlist. Namely, we start with the line <0,y> with maximum y (if y>N+1, we will first produce a netlist with more inputs than necessary, but they can be eliminated by substituting appropriate constants): d=6, <0,34>.
Then we look for the same pair after the sign “=>”:
It means that functions for passport (x,0,34,*) are built as (x,0,20,*) op (x+1,18,15,*) where “op” is “&” for x=0,2,4 . . . and “|” for x=1,3,5 . . . (“{1}” indicates it). In our case,
f—0—0—34=f—0—0—20 & f—1—18—15
where the indices are the shift amount and elements of the pair.
Then, we look for <0,20> and <18,15> after “=>”, etc.:
That is:
f—0—0—20=f—0—10—10|f—0—0—11 (“|”, because of “{0}”)
f—1—18—15=f—1—18—6|f—20—4—10 (“&”, because of “{1}” and the odd shift)
<4,10> is not available, so we have to look for the first (i.e. having minimum depth) <4+2n,10+2m>; in our case it is <10,10>
In Boolean form:
f—0—0—11=f—0—6—5|f—0—0—7
f—0—10—10=f—0—10—4 & f—11—2—7
f—1—18—6=f—1—14—2|f—17—2—6
f—20—4—10 is replaced by better one:
f—14—10—10=f—14—10—4 & f—25—2—7
<0,7> is not available (first better candidate is <2,7>)
In Boolean form, f—0—0—7 is replaced by (negative index is used temporarily)
f—−2—2—7=f—−2—2—4 & f—1—213 4.
Eliminating the negative index, replace f—−2—2—4 by f—0—0—4, producing actual expansion:
f—0—0—7=f—0—4 & f—1—2—4
The rest are given as:
f—0—6—5=f—0—6—2 & f—7—0—4
f—0—10—4=f—0—6—2 & f—8—2—4
f—1—14—2=f—1—6—2|f—9—6—2
f—11—2—7=f—11—2—4|f—14—2—4
f—14—10—4=f—14—6—2 & f—22—2—4
f—17—2—6=f—17—2—4|f—20—2—3
f—25—2—7=f—25—2—4|f—28—2—4
In Boolean form:
f—0—0—4=f—0—2—2|f—0—0—3
f—0—6—2=f—0—2—2 & f—4—2—2
f—1—2—4=f—1—2—2|f—4—0—3
f—1—6—2=f—1—2—2|f13 5—2—2
f—7—0—4=f—7—2—2 & f—7—0—3
f—8—2—4=f—8—2—2 & f—11—0—3
f—9—6—2=f—9—2—2|f—13—2—2
f—11—2—4=f—11—2—2|f—14—0—3
f—14—2—4=f—14—2—2 & f—17—0—3
f—14—6—2=f—14—2—2 & f—18—2—2
f—17—2—4=f—17—2—2|f—20—0—3
f—20—2—3=f—20—2—2 & f—23—0—2=f—20—2—2 & x23
f—22—2—4=f—22—2—2 & f—25—0—3
f—25—2—4=f—25—2—2|f—28—0—3
f—28—2—4=f—28—2—2 & f—31—0—3
In Boolean form:
f—0—0—3=f—0—0—2 & f—1—0—2=x0 & x1
f—0—2—2=f—0—0—2 & f—2—0—2=x0 & x2
f—1—2—2=f—1—0—2|f—3—0—2=x1|x3
f—4—0—3=f—4—0—2 & f—5—0—2=x4 & x5
f—4—2—2=f—4—0—2 & f—6—0—2=x4 & x6
f—5—2—2=f—5—0—2|f—7—0—2=x5|x7
f—7—0—3=f—7—0—2|f—8—0—2=x7|x8
f—7—2—2=f—7—0—2|f—9—0—2=x7|x9
f—8—2—2=f—8—0—2 & f—10—0—2=x8 & x10
f—9—2—2=f—9—0—2|f—11—0—2=x9|x11
f—11—0—3=f—11—0—2|f—12—0—2=x11|x12
f—11—2—2=f—11—0—2|f—13—0—2=x11|x13
f—13—2—2=f—13—0—2|f—15—0—2=x13|x15
f—14—0—3=f—14—0—2 & f—15—0—2=x14 & x15
f—14—2—2=f—14—0—2 & f—16—0—2=x14 & x16
f—17—0—3=f—17—0—2|f—18—0—2=x17|x18
f—17—2—2=f—17—0—2|f—19—0—2=x17|x19
f—18—2—2=f—18—0—2 & f—20—0—2=x18 & x20
f—20—0—3=f—20—0—2 & f—21—0—2=x20 & x21
f—20—2—2=f—20—0—2 & f—22—0—2=x20 & x22
f—22—2—2=f—22—0—2 & f—24—0—2=x22 & x24
f—25—0—3=f—25—0—2|f—26—0—2=x25|x26
f—25—2—2=f—25—0—2|f—27—0—2=x25|x27
f—28—0—3=f—28—0—2 & f—29—0—2=x28 & x29
f—28—2—2=f—28—0—2 & f—30—0—2=x28 & x30
f—31—0—3=f—31—0—2|f—32—0—2=x31|x32
The resulting 33-input circuit differs from the one produced by Algorithm B, but it has the same depth of six.
Particular low-depth methods for computing functions out=f′n(x0, . . . ,xn−1) for n=33, 60, 109, 202 and 375 are given below. The inputs are numbered from x0 to xn−1; for fn, replace “&” with “|” and vice-versa. All internal expressions named “f . . . ” have a depth of three, “g . . . ” have a depth of six, and “h . . . ” have a depth of nine. Numerical indices of these subexpressions correspond to the first primary input used by them. Optional letter-modifier (a,b,c . . . ) is used to resolve possible ambiguities if the numerical index is the same.
Inputs, Depth=6
60 Inputs, Depth=7
109 Inputs, Depth=8
Inputs, Depth=9
Inputs, Depth=10
There is described a new method for generating fast adders, comparators, and some other datapath modules. A comparison with existing methods is presented, and some particular netlists produced by the new method are shown in detail. Thus, the present method is efficient for n up to millions of inputs. For smaller numbers of inputs, the present method re-discovers the best-known (smallest depth) circuits. For larger numbers of inputs, the present method produces better circuits (smaller depth) than all presently-known methods.
The foregoing description of preferred embodiments for this invention has been presented for purposes of illustration and description. It is not intended to be exhaustive or to limit the invention to the precise form disclosed. Obvious modifications or variations are possible in light of the above teachings. The embodiments are chosen and described in an effort to provide the best illustrations of the principles of the invention and its practical application, and to thereby enable one of ordinary skill in the art to utilize the invention in various embodiments and with various modifications as are suited to the particular use contemplated. All such modifications and variations are within the scope of the invention as determined by the appended claims when interpreted in accordance with the breadth to which they are fairly, legally, and equitably entitled.
This application claims all rights and priority on U.S. provisional patent application 60/979,529 filed Oct. 12, 2007. This invention relates to the field of integrated circuit fabrication. More particularly, this invention relates to the design of integrated circuits.
| Number | Date | Country | |
|---|---|---|---|
| 60979529 | Oct 2007 | US |
