[ Chapter start ] [ Previous page ] [ Next page ]

---

5.1.1  ACT 1 Logic Module

The functional behavior of the Actel ACT 1 Logic Module is shown in Figure 5.1 (a). Figure 5.1 (b) represents a possible circuit-level implementation. We can build a logic function using an Actel Logic Module by connecting logic signals to some or all of the Logic Module inputs, and by connecting any remaining Logic Module inputs to VDD or GND. As an example, Figure 5.1 (c) shows the connections to implement the function F = A · B + B' · C + D. How did we know what connections to make? To understand how the Actel Logic Module works, we take a detour via multiplexer logic and some theory.

FIGURE 5.1  The Actel ACT architecture. (a) Organization of the basic logic cells. (b) The ACT 1 Logic Module. (c) An implementation using pass transistors (without any buffering). (d) An example logic macro. (Source: Actel.)

5.1.2  Shannon’s Expansion Theorem

In logic design we often have to deal with functions of many variables. We need a method to break down these large functions into smaller pieces. Using the Shannon expansion theorem, we can expand a Boolean logic function F in terms of (or with respect to) a Boolean variable A,

F = A · F (A = '1') + A' · F (A = '0'),(5.1)

where F (A = 1) represents the function F evaluated with A set equal to '1'.

For example, we can expand the following function F with respect to (I shall use the abbreviation wrt ) A,

F = A' · B + A · B · C' + A' · B' · C

= A · (B · C') + A' · (B + B' · C).(5.2)

We have split F into two smaller functions. We call F (A = '1') = B · C' the cofactor of F wrt A in Eq.  5.2 . I shall sometimes write the cofactor of F wrt A as F _A (the cofactor of F wrt A' is F _A' ). We may expand a function wrt any of its variables. For example, if we expand F wrt B instead of A,

F = A' · B + A · B · C' + A' · B' · C

= B · (A' + A · C') + B' · (A' · C).(5.3)

We can continue to expand a function as many times as it has variables until we reach the canonical form (a unique representation for any Boolean function that uses only minterms. A minterm is a product term that contains all the variables of F—such as A · B' · C). Expanding Eq.  5.3 again, this time wrt C, gives

F = C · (A' · B + A' · B') + C' · (A · B + A' · B).(5.4)

As another example, we will use the Shannon expansion theorem to implement the following function using the ACT 1 Logic Module:

F = (A · B) + (B' · C) + D.(5.5)

First we expand F wrt B:

F = B · (A + D) + B' · (C + D)

= B · F2 + B' · F1.(5.6)

Equation 5.6 describes a 2:1 MUX, with B selecting between two inputs: F (A = '1') and F (A = '0'). In fact Eq.  5.6 also describes the output of the ACT 1 Logic Module in Figure 5.1 ! Now we need to split up F1 and F2 in Eq.  5.6 . Suppose we expand F2 = F _B wrt A, and F1 = F _B' wrt C:

F2 = A + D = (A · 1) + (A' · D),(5.7)

F1 = C + D = (C · 1) + (C' · D).(5.8)

From Eqs.  5.6 – 5.8 we see that we may implement F by arranging for A, B, C to appear on the select lines and '1' and D to be the data inputs of the MUXes in the ACT 1 Logic Module. This is the implementation shown in Figure 5.1 (d), with connections: A0 = D, A1 = '1', B0 = D, B1 = '1', SA = C, SB = A, S0 = '0', and S1 = B.

Now that we know that we can implement Boolean functions using MUXes, how do we know which functions we can implement and how to implement them?

5.1.3 Multiplexer Logic as Function Generators

Figure 5.2 illustrates the 16 different ways to arrange ‘1’s on a Karnaugh map corresponding to the 16 logic functions, F (A, B), of two variables. Two of these functions are not very interesting (F = '0', and F = '1'). Of the 16 functions, Table 5.1 shows the 10 that we can implement using just one 2:1 MUX. Of these 10 functions, the following six are useful:

• INV. The MUX acts as an inverter for one input only.
• BUF. The MUX just passes one of the MUX inputs directly to the output.
• AND. A two-input AND.
• OR. A two-input OR.
• AND1-1. A two-input AND gate with inverted input, equivalent to an NOR-11.
• NOR1-1. A two-input NOR gate with inverted input, equivalent to an AND-11.

FIGURE 5.2  The logic functions of two variables.

TABLE 5.1  Boolean functions using a 2:1 MUX.
Function, F		F =	Canonical form	Minterms 1	Minterm code 2	Function number 3	M1 4
							A0	A1	SA
1	'0'	'0'	'0'	none	0000	0	0	0	0
2	NOR1-1(A, B)	(A + B')'	A' · B	1	0010	2	B	0	A
3	NOT(A)	A'	A' · B' + A' · B	0, 1	0011	3	0	1	A
4	AND1-1(A, B)	A · B'	A · B'	2	0100	4	A	0	B
5	NOT(B)	B'	A' · B' + A · B'	0, 2	0101	5	0	1	B
6	BUF(B)	B	A' · B + A · B	1, 3	1010	6	0	B	1
7	AND(A, B)	A · B	A · B	3	1000	8	0	B	A
8	BUF(A)	A	A · B' + A · B	2, 3	1100	9	0	A	1
9	OR(A, B)	A + B	A' · B + A · B' + A · B	1, 2, 3	1110	13	B	1	A
10	'1'	'1'	A' · B' + A' · B + A · B' + A · B	0, 1, 2, 3	1111	15	1	1	1

Figure 5.3 (a) shows how we might view a 2:1 MUX as a function wheel , a three-input black box that can generate any one of the six functions of two-input variables: BUF, INV, AND-11, AND1-1, OR, AND. We can write the output of a function wheel as

F1 = WHEEL1 (A, B).(5.9)

where I define the wheel function as follows:

WHEEL1 (A, B) = MUX (A0, A1, SA).(5.10)

The MUX function is not unique; we shall define it as

MUX (A0, A1, SA) = A0 · SA' + A1 · SA.(5.11)

The inputs (A0, A1, SA) are described using the notation

A0, A1, SA = {A, B, '0', '1'}(5.12)

to mean that each of the inputs (A0, A1, and SA) may be any of the values: A, B, '0', or '1'. I chose the name of the wheel function because it is rather like a dial that you set to your choice of function. Figure 5.3 (b) shows that the ACT 1 Logic Module is a function generator built from two function wheels, a 2:1 MUX, and a two-input OR gate.

FIGURE 5.3  The ACT 1 Logic Module as a Boolean function generator. (a) A 2:1 MUX viewed as a function wheel. (b) The ACT 1 Logic Module viewed as two function wheels, an OR gate, and a 2:1 MUX.

We can describe the ACT 1 Logic Module in terms of two WHEEL functions:

F = MUX [ WHEEL1, WHEEL2, OR (S0, S1) ](5.13)

Now, for example, to implement a two-input NAND gate, F = NAND (A, B) = (A · B)', using an ACT 1 Logic Module we first express F as the output of a 2:1 MUX. To split up F we expand it wrt A (or wrt B; since F is symmetric in A and B):

F = A · (B') + A' · ('1')(5.14)

Thus to make a two-input NAND gate we assign WHEEL1 to implement INV (B), and WHEEL2 to implement '1'. We must also set the select input to the MUX connecting WHEEL1 and WHEEL2, S0 + S1 = A—we can do this with S0 = A, S1 = '1'.

Before we get too carried away, we need to realize that we do not have to worry about how to use Logic Modules to construct combinational logic functions—this has already been done for us. For example, if we need a two-input NAND gate, we just use a NAND gate symbol and software takes care of connecting the inputs in the right way to the Logic Module.

How did Actel design its Logic Modules? One of Actel’s engineers wrote a program that calculates how many functions of two, three, and four variables a given circuit would provide. The engineers tested many different circuits and chose the best one: a small, logically efficient circuit that implemented many functions. For example, the ACT 1 Logic Module can implement all two-input functions, most functions with three inputs, and many with four inputs.

Apart from being able to implement a wide variety of combinational logic functions, the ACT 1 module can implement sequential logic cells in a flexible and efficient manner. For example, you can use one ACT 1 Logic Module for a transparent latch or two Logic Modules for a flip-flop. The use of latches rather than flip-flops does require a shift to a two-phase clocking scheme using two nonoverlapping clocks and two clock trees. Two-phase synchronous design using latches is efficient and fast but, to handle the timing complexities of two clocks requires changes to synthesis and simulation software that have not occurred. This means that most people still use flip-flops in their designs, and these require two Logic Modules.

5.1.4  ACT 2 and ACT 3 Logic Modules

Using two ACT 1 Logic Modules for a flip-flop also requires added interconnect and associated parasitic capacitance to connect the two Logic Modules. To produce an efficient two-module flip-flop macro we could use extra antifuses in the Logic Module to cut down on the parasitic connections. However, the extra antifuses would have an adverse impact on the performance of the Logic Module in other macros. The alternative is to use a separate flip-flop module, reducing flexibility and increasing layout complexity. In the ACT 1 family Actel chose to use just one type of Logic Module. The ACT 2 and ACT 3 architectures use two different types of Logic Modules, and one of them does include the equivalent of a D flip-flop.

Figure 5.4 shows the ACT 2 and ACT 3 Logic Modules. The ACT 2 C-Module is similar to the ACT 1 Logic Module but is capable of implementing five-input logic functions. Actel calls its C-module a combinatorial module even though the module implements combinational logic. John Wakerly blames MMI for the introduction of the term combinatorial [Wakerly, 1994, p. 404].

The use of MUXes in the Actel Logic Modules (and in other places) can cause confusion in using and creating logic macros. For the Actel library, setting S = '0' selects input A of a two-input MUX. For other libraries setting S = '1' selects input A. This can lead to some very hard to find errors when moving schematics between libraries. Similar problems arise in flip-flops and latches with MUX inputs. A safer way to label the inputs of a two-input MUX is with '0' and '1', corresponding to the input selected when the select input is '1' or '0'. This notation can be extended to bigger MUXes, but in Figure 5.4 , does the input combination S0 = '1' and S1 = '0' select input D10 or input D01? These problems are not caused by Actel, but by failure to use the IEEE standard symbols in this area.

The S-Module ( sequential module ) contains the same combinational function capability as the C-Module together with a sequential element that can be configured as a flip-flop. Figure 5.4 (d) shows the sequential element implementation in the ACT 2 and ACT 3 architectures.

FIGURE 5.4  The Actel ACT 2 and ACT 3 Logic Modules. (a) The C-Module for combinational logic. (b) The ACT 2 S-Module. (c) The ACT 3 S-Module. (d) The equivalent circuit (without buffering) of the SE (sequential element). (e) The sequential element configured as a positive-edge–triggered D flip-flop. (Source: Actel.)

5.1.5 Timing Model and Critical Path

Figure 5.5 (a) shows the timing model for the ACT family. ⁵ This is a simple timing model since it deals only with logic buried inside a chip and allows us only to estimate delays. We cannot predict the exact delays on an Actel chip until we have performed the place-and-route step and know how much delay is contributed by the interconnect. Since we cannot determine the exact delay before physical layout is complete, we call the Actel architecture nondeterministic .

Even though we cannot determine the preroute delays exactly, it is still important to estimate the delay on a logic path. For example, Figure 5.5 (a) shows a typical situation deep inside an ASIC. Internal signal I1 may be from the output of a register (flip-flop). We then pass through some combinational logic, C1, through a register, S1, and then another register, S2. The register-to-register delay consists of a clock–Q delay, plus any combinational delay between registers, and the setup time for the next flip-flop. The speed of our system will depend on the slowest register–register delay or critical path between registers. We cannot make our clock period any longer than this or the signal will not reach the second register in time to be clocked.

Figure 5.5 (a) shows an internal logic signal, I1, that is an input to a C-module, C1. C1 is drawn in Figure 5.5 (a) as a box with a symbol comprising the overlapping letters “C” and “L” (borrowed from carpenters who use this symbol to mark the centerline on a piece of wood). We use this symbol to describe combinational logic. For the standard-speed grade ACT 3 (we shall look at speed grading in Section 5.1.6 ) the delay between the input of a C-module and the output is specified in the data book as a parameter, t _PD , with a maximum value of 3.0 ns.

The output of C1 is an input to an S-Module, S1, configured to implement combinational logic and a D flip-flop. The Actel data book specifies the minimum setup time for this D flip-flop as t _SUD = 0.8 ns. This means we need to get the data to the input of S1 at least 0.8 ns before the rising clock edge (for a positive-edge–triggered flip-flop). If we do this, then there is still enough time for the data to go through the combinational logic inside S1 and reach the input of the flip-flop inside S1 in time to be clocked. We can guarantee that this will work because the combinational logic delay inside S1 is fixed.

FIGURE 5.5  The Actel ACT timing model. (a) Timing parameters for a 'Std' speed grade ACT 3. (Source: Actel.) (b) Flip-flop timing. (c) An example of flip-flop timing based on ACT 3 parameters.

The S-Module seems like good value—we get all the combinational logic functions of a C-module (with delay t _PD of 3 ns) as well as the setup time for a flip-flop for only 0.8 ns? …not really. Next I will explain why not.

Figure 5.5 (b) shows what is happening inside an S-Module. The setup and hold times, as measured inside (not outside) the S-Module, of the flip-flop are t' _SUD and t' _H (a prime denotes parameters that are measured inside the S-Module). The clock–Q propagation delay is t' _CO . The parameters t' _SUD , t' _H , and t' _CO are measured using the internal clock signal CLKi. The propagation delay of the combinational logic inside the S-Module is t' _PD . The delay of the combinational logic that drives the flip-flop clock signal ( Figure 5.4 d) is t' _CLKD .

From outside the S-Module, with reference to the outside clock signal CLK1:

t _SUD = t' _SUD + (t' _PD – t' _CLKD ),

t _H = t' _H + (t' _PD – t' _CLKD ),

t _CO = t' _CO + t' _CLKD .(5.15)

Figure 5.5 (c) shows an example of flip-flop timing. We have no way of knowing what the internal flip-flop parameters t' _SUD , t' _H , and t' _CO actually are, but we can assume some reasonable values (just for illustration purposes):

t' _SUD = 0.4 ns, t' _H = 0.1 ns, t' _CO = 0.4 ns.(5.16)

We do know the delay, t' _PD , of the combinational logic inside the S-Module. It is exactly the same as the C-Module delay, so t' _PD = 3 ns for the ACT 3. We do not know t' _CLKD ; we shall assume a reasonable value of t' _CLKD = 2.6 ns (the exact value does not matter in the following argument).

Next we calculate the external S-Module parameters from Eq.  5.15 as follows:

t _SUD = 0.8 ns, t _H = 0.5 ns, t _CO = 3.0 ns.(5.17)

These are the same as the ACT 3 S-Module parameters shown in Figure 5.5 (a), and I chose t' _CLKD and the values in Eq.  5.16 so that they would be the same. So now we see where the combinational logic delay of 3.0 ns has gone: 0.4 ns went into increasing the setup time and 2.6 ns went into increasing the clock–output delay, t _CO .

From the outside we can say that the combinational logic delay is buried in the flip-flop setup time. FPGA vendors will point this out as an advantage that they have. Of course, we are not getting something for nothing here. It is like borrowing money—you have to pay it back.

5.1.6  Speed Grading

Most FPGA vendors sort chips according to their speed ( the sorting is known as speed grading or speed binning , because parts are automatically sorted into plastic bins by the production tester). You pay more for the faster parts. In the case of the ACT family of FPGAs, Actel measures performance with a special binning circuit , included on every chip, that consists of an input buffer driving a string of buffers or inverters followed by an output buffer. The parts are sorted from measurements on the binning circuit according to Logic Module propagation delay. The propagation delay, t _PD , is defined as the average of the rising ( t _PLH ) and falling ( t _PHL ) propagation delays of a Logic Module

t _PD = ( t _PLH + t _PHL )/2.(5.18)

Since the transistor properties match so well across a chip, measurements on the binning circuit closely correlate with the speed of the rest of the Logic Modules on the die. Since the speeds of die on the same wafer also match well, most of the good die on a wafer fall into the same speed bin. Actel speed grades are: a 'Std' speed grade, a '1' speed grade that is approximately 15 percent faster, a '2' speed grade that is approximately 25 percent faster than 'Std', and a '3' speed grade that is approximately 35 percent faster than 'Std'.

5.1.7 Worst-Case Timing

If you use fully synchronous design techniques you only have to worry about how slow your circuit may be—not how fast. Designers thus need to know the maximum delays they may encounter, which we call the worst-case timing . Maximum delays in CMOS logic occur when operating under minimum voltage, maximum temperature, and slow–slow process conditions. (A slow–slow process refers to a process variation, or process corner , which results in slow p -channel transistors and slow n -channel transistors—we can also have fast–fast, slow–fast, and fast–slow process corners.)

Electronic equipment has to survive in a variety of environments and ASIC manufacturers offer several classes of qualification for different applications:

• Commercial. VDD = 5 V ± 5 %, T _A (ambient) = 0 to +70 °C.
• Industrial. VDD = 5 V ± 10 %, T _A (ambient) = –40 to +85 °C.
• Military: VDD = 5 V ± 10 %, T _C (case) = –55 to +125 °C.
• Military: Standard MIL-STD-883C Class B.
• Military extended: Unmanned spacecraft.

ASICs for commercial application are cheapest; ASICs for the Cruise missile are very, very expensive. Notice that commercial and industrial application parts are specified with respect to the ambient temperature T _A (room temperature or the temperature inside the box containing the ASIC). Military specifications are relative to the package case temperature , T _C . What is really important is the temperature of the transistors on the chip, the junction temperature , T _J , which is always higher than T _A (unless we dissipate zero power). For most applications that dissipate a few hundred mW, T _J is only 5–10 °C higher than T _A . To calculate the value of T _J we need to know the power dissipated by the chip and the thermal properties of the package—we shall return to this in Section 6.6.1, “Power Dissipation.”

Manufacturers have to specify their operating conditions with respect to T _J and not T _A , since they have no idea how much power purchasers will dissipate in their designs or which package they will use. Actel used to specify timing under nominal operating conditions: VDD = 5.0 V, and T _J = 25 °C. Actel and most other manufacturers now specify parameters under worst-case commercial conditions: VDD = 4.75 V, and T _J = +70 °C.

Table 5.2 shows the ACT 3 commercial worst-case timing. ⁶ In this table Actel has included some estimates of the variable routing delay shown in Figure 5.5 (a). These delay estimates depend on the number of gates connected to a gate output (the fanout).

When you design microelectronic systems (or design anything ) you must use worst-case figures ( just as you would design a bridge for the worst-case load). To convert nominal or typical timing figures to the worst case (or best case), we use measured, or empirically derived, constants called derating factors that are expressed either as a table or a graph. For example, Table 5.3 shows the ACT 3 derating factors from commercial worst-case to industrial worst-case and military worst-case conditions (assuming T _J = T _A ). The ACT 1 and ACT 2 derating factors are approximately the same. ⁷

TABLE 5.2  ACT 3 timing parameters. 8
		Fanout
Family	Delay 9	1	2	3	4	8
ACT 3-3 (data book)	t PD	2.9	3.2	3.4	3.7	4.8
ACT3-2 (calculated)	t PD /0.85	3.41	3.76	4.00	4.35	5.65
ACT3-1 (calculated)	t PD /0.75	3.87	4.27	4.53	4.93	6.40
ACT3-Std (calculated)	t PD /0.65	4.46	4.92	5.23	5.69	7.38
Source: Actel.

TABLE 5.3  ACT 3 derating factors. 10
	Temperature T J ( junction) / °C
V DD / V	–55	–40	0	25	70	85	125
4.5	0.72	0.76	0.85	0.90	1.04	1.07	1.17
4.75	0.70	0.73	0.82	0.87	1.00	1.03	1.12
5.00	0.68	0.71	0.79	0.84	0.97	1.00	1.09
5.25	0.66	0.69	0.77	0.82	0.94	0.97	1.06
5.5	0.63	0.66	0.74	0.79	0.90	0.93	1.01
Source: Actel.

As an example of a timing calculation, suppose we have a Logic Module on a 'Std' speed grade A1415A (an ACT 3 part) that drives four other Logic Modules and we wish to estimate the delay under worst-case industrial conditions. From the data in Table 5.2 we see that the Logic Module delay for an ACT 3 'Std' part with a fanout of four is t _PD = 5.7 ns (commercial worst-case conditions, assuming T _J = T _A ).

If this were the slowest path between flip-flops (very unlikely since we have only one stage of combinational logic in this path), our estimated critical path delay between registers , t _CRIT , would be the combinational logic delay plus the flip-flop setup time plus the clock–output delay:

t _CRIT (w-c commercial) = t _PD + t _SUD + t _CO

= 5.7 ns + 0.8 ns + 3.0 ns = 9.5 ns .(5.19)

(I use w-c as an abbreviation for worst-case.) Next we need to adjust the timing to worst-case industrial conditions. The appropriate derating factor is 1.07 (from Table 5.3 ); so the estimated delay is

t _CRIT (w-c industrial) = 1.07 ¥ 9.5 ns = 10.2 ns .(5.20)

Let us jump ahead a little and assume that we can calculate that T _J = T _A + 20 °C = 105 °C in our application. To find the derating factor at 105 °C we linearly interpolate between the values for 85 °C (1.07) and 125 °C (1.17) from Table 5.3 ). The interpolated derating factor is 1.12 and thus

t _CRIT (w-c industrial, T _J = 105 °C) = 1.12 ¥ 9.5 ns = 10.6 ns ,(5.21)

giving us an operating frequency of just less than 100 MHz.

It may seem unfair to calculate the worst-case performance for the slowest speed grade under the harshest industrial conditions—but the examples in the data books are always for the fastest speed grades under less stringent commercial conditions. If we want to illustrate the use of derating, then the delays can only get worse than the data book values! The ultimate word on logic delays for all FPGAs is the timing analysis provided by the FPGA design tools. However, you should be able to calculate whether or not the answer that you get from such a tool is reasonable.

5.1.8 Actel Logic Module Analysis

The sizes of the ACT family Logic Modules are close to the size of the base cell of an MGA. We say that the Actel ACT FPGAs use a fine-grain architecture . An advantage of a fine-grain architecture is that, whatever the mix of combinational logic to flip-flops in your application, you can probably still use 90 percent of an Actel FPGA. Another advantage is that synthesis software has an easier time mapping logic efficiently to the simple Actel modules.

The physical symmetry of the ACT Logic Modules greatly simplifies the place-and-route step. In many cases the router can swap equivalent pins on opposite sides of the module to ease channel routing. The design of the Actel Logic Modules is a balance between efficiency of implementation and efficiency of utilization. A simple Logic Module may reduce performance in some areas—as I have pointed out—but allows the use of fast and robust place-and-route software. Fast, robust routing is an important part of Actel FPGAs (see Section 7.1, “Actel ACT”).