# Circuit Timing

Updated 2018-03-09

Often the speed of the circuit is constrained by:

• Throughput constraints
• Processing constraints

The performance of an operation is given by the expression:

$t=\text{# cycles}\times{\text{cycle time}}$

The number of cycles can be optimized by having a well designed datapath, the cycle time can be improved by increasing clock frequency (but only to a certain point).

## Delay

### Delay of Gate

Consider the simple logic of two inverters (page 5). Recall from CPEN 211, that this is composed of a bunch of CMOS transistors. If the input is changing from HIGH to LOW, what is actually happening?

There are two cases for PMOS and NMOS transistors.

page 6

Nonetheless, there exists resistance. The resistance depends on the size of the transistor, the length of wire connecting the gates, and temperature.

Fact: There also exist parasitic capacitances attached to every wire and transistor due to physical transistor structure.

The capacitance depends on the size of transistor, the number of gates being driven (fan-out) and length of wire connecting the gates.

Fan-Out describes the number of gates connected down-stream.

Because of the parasitic capacitances, we get a RC model. Thus the delay comes from the transient behavior of the RC circuit.

The analysis tool creates an equivalent circuit of resistor and capacitor and solves for the time it takes to reach steady state. The tool takes in account of all variables such as transistor size, temperature and solves the equations.

### Delay in FPGA

The delay comes from:

• Logic delay: the delay in the logic blocks (but this is actually quite fast and can support up to 10GHz)
• Routing delay: the routing is actually much slower because the path is consisting of many configurable MUXs. (can only support up to 1GHz). This is one reason why placement of blocks is important.

The delay for both is modelled as one entity which helps with the simplicity of calculations.

## Combinational Timing Constraints

### Gate Propagation Delay

The gate delay, denoted by $$t_\text{gate}$$, is the time that it takes for combinational gate to output change after the input changes.

page 20

### Critical Path Delay

The path delay, denoted by $$t_\text{path}$$, is the delay through a series of combinational gates. Specifically, this is the time it takes for the output of the series of gates to change after the inputs to the path has changed.

page 21

The critical path delay is the delay in the longest in the path used.

• Some output will take longer to settle
• Some output will glitch to a different value and go back and forth before settling to a final value

#### Synchronization

Problem: the signals are all coming out at the different times, so we need to synchronize them.

Solution: flip-flops.

page 23

### Clock Speed

If the $$t_\text{path}$$ is 5 ns, then we can’t have a clock frequency with period less than the delay time. For combinational logic, slower clock doesn’t matter as it will just give more time for the output to settle.

## Flip-Flop Timing Constraints

### Clock-to-Q Delay

page 35

The FF has data input, output, and clock input. The input is stabilized at some point, then comes the clock. The clock then samples the input. But the output q still will take some time to take effect.

The clock-to-Q delay, denoted as $$t_\text{clk-to-q}$$, it the delay between rising edge of clock, and when output changes.

### Setup Time

Just like how the output needs some time to take effect, there also exists some delay for the input to take effect. Hence:

The setup time, denoted by $$t_\text{setup}$$, is the minimum time that the input to the flip-flop must be stable / settled right before the clock edge. The input should not change during this period.

page 36

#### Setup Requirement

Input value must be ready for destination flop ahead of when the rising clock edge arrives.

page 41

Now the critical path goes through:

1. source FF’s output can settle to final value (source clock-to-q time)
2. critical path settle time (critical path delay)
3. value arrives destination FF early enough for setup time (destination setup time)
$t_\text{clock}\geq t_\text{clk-to-q max} + t_\text{CP} + t_\text{setup}$

Setup time violations can be fixed by:

1. Having a more optimized critical path by moving things around to shorten the delay
2. Slow down clock frequency

### Hold Time

The hold time, denoted by $$t_\text{hold}$$, is the minimum time required for the input to be stable right after the clock edge. The input should not change during this period.

If the input change before within hold time, then we cannot guarantee that the input is successfully sampled by the clock edge.

page 37

#### Hold Requirements

page 46

Input value of destination flop must hold after rising clock arrives.

Long hold times can cause problems with the faster non-critical paths. The fast path settles very quickly but the destination FF is still reading in “old” value from fast path logic.

Thus, the hold time needs to account for:

1. Fastest source FF settle time (source minimum clock-to-q time)
2. Fastest path delay
3. Destination
$t_\text{clk-to-q min} + t_\text{path} \geq t_\text{hold}$

Hold time requirements can only be fixed by increasing the delay in the non-critical paths by adding buffers, which are pairs of inverters. This cannot be addressed by changing the clock frequency.