5.4.4 Error Propagation

heavily on the (possibly coloured) spectrum of the input sequence. These two dimensions of dependence, between pairs of error inputs and over time, require a more sophisticated error estimation model.

-1 z

(b) the corresponding linearization

Fig. 5.10. Linearization of the saturation nonlinearities

Estimating the cross-correlation function between saturation inputs is possible but computationally intensive. Although in general there is no solution to this problem in linear time, a bound can certainly be placed on the error power at the system outputs, and this bound can be calculated in linear time.

Claim. In a saturation system let there be a total of p saturation nonlinearities, with corresponding linearized error inputs e1, . . . , ep of standard deviations σe1 , . . . , σep . Let us concentrate on a single primary output with error y, and let Hi(z) denote the transfer function from error input ei to this output. Then (5.9) holds.

Proof:

The value of the error y at time index t (at any specific output) is then given by the convolution in (5.10). Here bi represents the impulse response from error input i to the output in question.

p∞

i=1 k=0

94 5 Saturation Arithmetic

Assuming statistically stationary input signals, we obtain (5.11) for the general saturation-induced error power at the output. Here rei1 ei2 is the crosscorrelation function rei1 ei2 [τ ] = E{ei1 [t]ei2 [t − τ ]}.

p p ∞ ∞

The Cauchy-Schwartz inequality (5.12) [Gar90] may be invoked, allowing (5.11) to be separated, as in (5.13). Here σei represents the standard deviation of error input ei and Hi(z) is the transfer function from that input to the output in question.

E2{XY } ≤ E{X2}E{Y 2}

(5.12)

for zero-mean random variables X and Y

≤σei 1{Hi(z)}

i=1

Of course such a bound may be more or less close to the empirical error power. The true measure of usefulness for this bound in real applications, is that the circuits synthesized using this measure of error are at least of comparable area to those synthesized using traditional simulation-based average case scaling, preferably smaller. This measure will be tested in Section 5.6.

5.4.5 Reducing Bound Slackness

There are certain transformations which may be performed on the graph representation of a saturation system without a ecting the global system behaviour. A saturation nonlinearity may be moved through a constant coe cient multiplication, a move accompanied by a corresponding scaling in the saturation cut-o parameter (Fig. 5.11(a)). In addition, two consecutive nonlinearities can be merged (Fig. 5.11(b)), and multiple nonlinearities following a branching node can be reconfigured (Fig. 5.11(c)). Although these transformations do not result in di erent system behaviour from an external perspective, the estimated saturation error resulting from the procedure described above can di er, due to di erent slackness in the Cauchy-Schwartz derived upper bound. It is useful to minimize this slackness. Note that the transformation in Fig. 5.11(c) has been used in Section 5.2 to minimize the implementation cost of a fork node. However the two applications of this transformation

for c 1>= c2>= ... >= cn

(c)

Fig. 5.11. Useful saturation transformations

are entirely separate: applying the transformation for saturation error modelling in no way suggests altering the physical realization of the saturation nonlinearity.

Example 5.9. Applying these transformations to the second order section shown in Fig. 5.12(a) results in the improved saturation system in Fig. 5.12(b); W1 and W2 are wiring constructs where the outputs are a permuted version of the inputs, and S1 and S2 are saturation constructs with possible forms illustrated in Figs. 5.12(c) and (d) respectively. Applying the saturation noise model to this construction can result in a tighter Cauchy-Schwartz bound.

Claim. For the transformation shown in Fig. 5.11(b), it is always desirable to merge the two nonlinearities.

Proof:

Let the linearized error inputs at the saturation nonlinearities with cut-o s c1 and c2 be e1[t] and e2[t] of variance σe1 and σe2 , respectively. Similarly, let the error input at the saturation nonlinearity with cut-o min(c1, c2) be e[t] of variance σe. Since there are no branches between nonlinearities, (5.13) will not be increased by merging i the error standard deviations obey σe1 + σe2 ≥ σe. However it is clear that e[t] = e1[t] + e2[t] and therefore application of (5.12)

reveals that this is indeed the case since σe2 = σe21 + σe22 + 2E{e1[t]e2[t]} and

σe1 + σe2 ≥ σe σe21 + σe22 + 2σe1 σe2 ≥ σe2.

The transformation shown in Fig. 5.11(c) will not always improve the error bound, since the 1 scaling from saturation error with cut-o ci, 1 ≤ i < n, is di erent in the two cases. Although the error injected due to the saturations with cut-o s cj , 2 ≤ j ≤ n may be reduced, whether this is o set by the change in scaling is dependent on the system transfer functions. For a general n-way

(b)

c4 >= c5

(d)

Fig. 5.12. Reducing estimate slackness in a second order IIR filter through saturation transformations: (a) original model (b) transformed model (c) possible forms of S1 (d) possible forms of S2

branching node, the situation becomes more complex still; any tree structure of nonlinearities may be used, so long as the partial order implied by the tree does not violate the numerical order of nonlinearity cut-o s. In practical cases it is often true that the right hand side of Fig. 5.11(c) represents the best error performance. Often when considering saturation arithmetic one is interested in recursive filters, which are typically constructed as a cascade of second order sections. In each second order section, there is one three-way and one two-way branching node. These nodes have su ciently small outdegree that the search for an optimal ordering can be performed by exhaustive search; the di erent configurations possible are illustrated in Figs. 5.12(c) and (d) for the three-way and two-way branches, respectively. For more general structures, simple search procedures could be used to determine a reasonable modelling configuration of nonlinearities, or the default configuration of Fig. 5.11(c)

could be used. In any case it is important to note that the configuration does not a ect the correctness of the bound in (5.13), only the quality of the bound.

These transformations are combined in Algorithm SlackReduce for a general saturation computation graph. Saturation nonlinearities are propagated ‘backwards’ through the computation graphs, in the reverse direction to the data-flow. Back propagation allows nonlinearities to come together from different branches of a fork, and perhaps propagate back through the fork reducing the Cauchy-Schwartz bound. In contrast forward propagation would not allow merging of nonlinearities, as nonlinearities do not cross adder nodes. In Algorithm SlackReduce the details of fork nodes are omitted for brevity. Note that for a fork node a simple heuristic is used: the nonlinearities are sorted in order and the transformation illustrated in Fig. 5.11(c) is applied. This approach is used instead of the exhaustive search (described above for the special case of IIR filters in second order sections), for three reasons. Firstly it has been observed in practice that with respect to the error contribution of the fork node, this arrangement is the most common arrangement to result in minimal Cauchy-Schwartz bound. Secondly by moving the saturation nonlinearity with maximum cut-o to the inedge of the fork node it is possible to further apply slack-reducing saturation transformations to predecessors of the fork node. Thirdly this arrangement is independent of the 1 scalings, and so the entire computation graph can be treated as one rather than considering each output separately. However because of this heuristic decision it cannot be guaranteed that E2 ≤ E1 for all input graphs.

Algorithm 5.2 Algorithm SlackReduce

Input: An saturation computation graph GS (V, S, C), having Cauchy-Schwartz bound E1

Output: An equivalent saturation computation graph, having Cauchy-Schwartz bound E2

begin do

foreach v V : ((v, v ), c) C do switch type(v)

case gain:

Set C ← C {(inedge(v), c/coef(v))} − {((v, v ), c)}

case delay:

Set C ← C {(inedge(v), c)} − {((v, v ), c)} case fork:

Apply transformation shown in Fig. 5.11(c), modify V , S and C accordingly

end switch

end foreach

C ← C − {(j, c) C : (j, c ) C, c < c} while C has changed during current iteration