DSP - BLOCK COEFFICIENT OF VARIATION

Introduction link

The Block Coefficient of Variation block chops the input stream into consecutive blocks of N samples and, at the end of each block, publishes the relative dispersion of that block:

$$ \bar{x} = \frac{1}{N}\sum_{i=0}^{N-1} x_i, \qquad \sigma = \sqrt{\frac{1}{N}\sum_{i=0}^{N-1}(x_i-\bar{x})^2}, \qquad \mathrm{CV} = \frac{\sigma}{\bar{x}} $$

N is a runtime input, not a property. You drive the exponent on the EXP pin and the block size is $N = 2^{\mathrm{EXP}}$:

What it is FOR link

$\sigma$ on its own answers the wrong question whenever two channels sit at different gains: a detector at 10x gain has ten times the $\sigma$ of the same detector at 1x and is not one bit noisier. The coefficient of variation is dimensionless and scale free - multiply every sample by ten and it does not move - so it is the number that actually compares:

• “is this detector noisier than that one” across channels with different gains, different couplings or different units;
• relative stability / RSD of a slow-control reading, a supply rail or a temperature - the figure that specifications are normally written in (“stable to 0.1%”);
• normalised noise monitoring over time on a channel whose absolute level drifts, where a rising CV means the noise grew rather than the signal shrank;
• Fano-like / counting statistics checks, where a Poisson process has a predictable $\sigma/\mathrm{mean}$ and a departure from it means something else is going on.

The units cancel, and so does N link

This block does no fixed-point scaling at all. In raw integer terms, with $S_1 = \sum x_i$ and $S_2 = \sum x_i^2$ and $\mathrm{var_num} = N!\cdot!S_2 - S_1^2$:

$$ \sigma = \frac{\sqrt{\mathrm{var_num}}}{N}, \qquad \bar{x} = \frac{S_1}{N}, \qquad \mathrm{CV} = \frac{\sqrt{\mathrm{var_num}}}{S_1} $$

No $2^{-\mathrm{IN_{fract}}}$ and no N anywhere. The input Q format does not enter this core’s arithmetic at all - it is a plain ratio of two raw integers. (The input width still sets the length of the serial engines; it is the scaling that cancels.)

Signed by default, and on purpose link

$\sigma$ is non negative but the mean is not, so CV carries the sign of the mean and the default output format is SIGNED. If you select an UNSIGNED format, a block whose mean is negative clamps to 0 - so pick UNSIGNED only when you know the mean is positive: a rate, a count, a rectified envelope, a unipolar supply rail.

Cost link

Per clock: one multiplier for $x^2$ (unavoidable at one sample per clock) and two accumulators, $S_1$ and $S_2$. In the tail: three serial engines, one reused stage each - a shift-add squarer for $|S_1|\cdot|S_1|$, a digit recurrence for $\sqrt{\mathrm{var_num}}$ and a restoring divider for the ratio - all taking one step per clock. What you pay for the tail is clocks, not comparators, and there is no DSP in the tail at all.

Block Coefficient of Variation or Block SNR? link

Block SNR computes $\mathrm{mean}/\sigma$ - the exact reciprocal of this block. Both exist because a reciprocal is not free in fixed point: pick the one whose interesting values land in the middle of its Q format rather than crammed against one end.

A clean 60 dB measurement has cv = 0.001, which in the default Q4.12 format is four LSBs - use Block SNR instead. A noisy or nearly-zero-mean channel has cv around 1 and an snr near 0 - use this block. The two cost exactly the same tail for the same number of output fractional bits.

When to use this instead of Block Statistics link

The all-in-one Block Statistics block is not deprecated, but it does not compute this statistic: its outputs include MEAN, VARIANCE, STDDEV, RMS, SUM, SUM_SQ, min/max, CREST and the rest, but there is no coefficient-of-variation pin. So:

• you want several statistics of the SAME block and the coefficient of variation - place a Block Statistics block for the rest and this block alongside it. They will each keep their own accumulators, which is the price of a statistic the all-in-one does not have.
• you want exactly one number - use this block on its own. Then you synthesise only that number: two accumulators, three serial engines and nothing else reaches the synthesiser.

Note that dividing Block Statistics’ STDDEV by its MEAN downstream is not the same thing: those two are each requantised into their own Q format first, and the quotient of two rounded numbers is much worse than this block’s 1 LSB. Here the ratio is formed from the exact integers.

Pin Description link

Properties link

Timing: the serial tail link

All post-accumulation arithmetic is serial - the block has a whole block period of slack after the N-th sample, so there is no reason to build a parallel datapath for it. The state walk is

  IDLE -(block complete)-> MUL x (IN_SW + EXP) -> VAR -> LD -> SQRT x ROOTW
     -> CLD -> DIV x CNUMW -> FIN -> IDLE
  

the squarer, the square root and the divider run back to back, each one reused stage taking one step per clock. OUT_DV pulses for one clock when the tail COMPLETES - not when the N-th sample arrives - and CV is updated on that same clock and on no other. The latency from the N-th accepted sample to the OUT_DV pulse, counted in clocks, is

$$ L = 2 + (\mathrm{IN_SW} + \mathrm{EXP} + 1) + (\mathrm{ROOTW} + 1) + (\mathrm{CNUMW} + 1) $$

with the two engine widths fixed at compile time:

$$ \mathrm{ROOTW} = \mathrm{IN_SW} + \mathit{MaxBlockExponent} + 4 $$

$$ \mathrm{CNUMW} = \max\bigl(\mathrm{ROOTW} + \mathrm{CV_{fract}},; \mathrm{CV\ width} + 6\bigr) $$

where $\mathrm{IN_SW}$ is the total input width, plus one bit if the input is UNSIGNED (a sample has to be promoted to signed first). For any sane configuration the first term of the $\max$ wins, and collecting terms gives a useful rule of thumb:

$$ L = 3,\mathrm{IN_SW} + 2,\mathit{MaxBlockExponent} + \mathrm{CV_{fract}} + \mathrm{EXP} + 13 $$

Note the Max Block Exponent row. Unlike Block Std Dev and Block Std Error of Mean, whose engines are sized by the output format, this block’s root is sized by the width of the internal $\mathrm{var_num}$ - which is what keeps the accuracy of the ratio independent of how many bits you gave the answer, but which also means every unit of Max Block Exponent costs two clocks of tail. Keep it at the largest block you actually use.

Worked numbers link

For a 16 bit signed input, Max Block Exponent 20, at the default CV format (Q4.12 signed):

• $\mathrm{ROOTW} = 16 + 20 + 4 = 40$
• $\mathrm{CNUMW} = \max(40 + 12,\ 16 + 6) = 52$
• $L = 2 + (16 + \mathrm{EXP} + 1) + (40 + 1) + (52 + 1) = 113 + \mathrm{EXP}$
• at EXP = 10 (N = 1024) that is 123 clocks, well inside the block;
• the smallest exponent with $2^{\mathrm{EXP}} \ge 113+\mathrm{EXP}$ is EXP = 7, i.e. N = 128 ($128 \ge 120$; at EXP = 6, $64 < 119$).

A few more configurations, to show where the clocks go:

A longer block gives more slack than it costs. $L$ grows by one clock per unit of EXP while $2^{\mathrm{EXP}}$ doubles, so $2^{\mathrm{EXP}} \ge L$ gets easier as EXP grows, not harder. The constraint only ever bites at the short end - and on this block it bites at a fairly long block, EXP = 7 or 8 rather than the EXP = 1 of Block Mean.

The 2^EXP >= L rule, and what happens when it is broken link

The tail of one block must finish before the next block completes:

$$ 2^{\mathrm{EXP}} \ge L $$

If a block completes while the previous tail is still running, that block’s result is DROPPED: there is no OUT_DV for it, the accumulators are unaffected and the following blocks come out correctly, but a result is silently skipped. There is no error pin for it.

The property page refuses a configuration whose minimum exponent exceeds Max Block Exponent, and CompileHDL prints both numbers - the worst-case tail length and the minimum usable EXP - in the compilation log, so the static half of the problem is caught for you.

But EXP is a PIN. Nothing can stop a design driving it too low at RUN TIME, and this is one of the blocks where that bites hardest: with L above a hundred clocks, an EXP of 5 or 6 that would be perfectly reasonable on Block Mean drops every result here, with no indication other than a silent OUT_DV. If EXP is under software control, clamp it in software to the minimum the compiler printed.

When the mean is zero link

mean == 0 is a real case, and it is not an error: a zero-mean signal has an unbounded coefficient of variation. The core detects it on the denominator ($S_1 = 0$) and forces the answer:

Both forced cases ignore the Saturation property, because neither is a requantisation overflow - they are the definition of the ratio breaking down. In the unbounded case the sign is meaningless (the mean is zero, so it is neither positive nor negative), and the saturation is taken as positive.

Note that a bipolar signal centred on zero will land in this case routinely

• which is a good reason to prefer CV on unipolar quantities, and to reach for Block Std Dev when the mean genuinely is zero.

Accuracy link

$\mathrm{var_num} = N!\cdot!S_2 - S_1^2$ is an exact integer: $N\cdot S_2$ is a shift (N is a power of two) and $S_1^2$ is an exact serial shift-add product. It is never two truncated quotients subtracted from each other.

The numerator root is taken at full internal precision, with $\mathrm{SQG} = 4$ guard bits below the LSB the divider needs - so the accuracy of the ratio does not depend on how many bits you gave the answer. (Contrast Block Crest Factor, whose denominator is an internal RMS in a user-chosen Q format, and whose errors therefore compound.) The root is up to 1 ulp low at $2^{-\mathrm{SQG}}$ of a CV LSB, the quotient is floored and the final requantisation rounds, so

CV is accurate to within 1 LSB.

The host regression enforces exactly 1 LSB, never more, against a Python golden computed in exact rational arithmetic.

Accumulation and IN_DV link

IN_DV is the only qualifier. It says “this clock carries a sample”: a sample is added to $S_1$, squared and added to $S_2$, and counts towards N, exactly on the clocks where IN_DV is high. Clocks with IN_DV low are ignored completely - whatever sits on IN during them cannot corrupt the block - while the serial tail keeps running, which is what you want: the tail has nothing to do with the input stream.

Unconnected, IN_DV ties to '1' and EXP ties to 10 (N = 1024), so the block free-runs with nothing wired except IN - and at N = 1024 the tail hides comfortably for the default formats, which is not true of every value you might drive.

There is deliberately no CE pin. On the all-in-one Block Statistics block an earlier revision had one, and it did not survive synthesis: with nothing but internal state gated by it, Vitis could reason the frozen path away and delete the port from the generated entity while SciCompiler’s wrapper still wired it, which failed a real Vivado build with [VRFC 10-718] formal port <ce> does not exist in entity. The whole per-operator family was built without one. To stall this block, gate its IN_DV - and note that there would be no reason to stall the tail anyway.

When EXP changes link

EXP is clamped to Max Block Exponent and then latched on the first accepted sample of a block, and held for that whole block. A change therefore takes effect on the NEXT block: a block in progress always finishes against the N it was started with, and a block is never emitted against a different N than the one it was accumulated with. The latched value is what $S_2$ is shifted by to form $\mathrm{var_num}$, and it also sets the length of the serial squarer.

Because N cancels out of the ratio, CV values taken at different EXP are directly comparable - unlike, say, Block Energy. Remember that EXP still has to satisfy $2^{\mathrm{EXP}} \ge L$ at run time, every time.

Knowing where the block is: BUSY, INTEGRATING and SAMPLE_COUNT link

Three optional status outputs, all defaulting to NO. They answer different questions, and on this block the difference is at its most useful, because the tail is long:

Every output of this block is a register, so each status bit is observed on the clock after the event that sets it:

• INTEGRATING rises on the clock after the FIRST sample of a block is accepted and falls on the clock after the N-th - it is high exactly while the block is ACCUMULATING. BUSY high with INTEGRATING low is precisely the square-root-then-divide tail.
• BUSY covers the accumulation and the tail. It rises with INTEGRATING, stays high across the tail, and its LAST HIGH CLOCK IS THE OUT_DV PULSE; it falls on the clock after.
• On a continuous stream the next block starts before the previous tail ends, so BUSY never drops and INTEGRATING dips for exactly one clock per block boundary - which makes it a free block marker.
• SAMPLE_COUNT is a fixed 32 bits and reads 1 after the first accepted sample, N after the N-th. It is NOT cleared at the block end: it HOLDS N through the tail and past OUT_DV, until the first sample of the next block takes it back to 1. so it reads N at OUT_DV only when the input STOPS for the whole tail; on a CONTINUOUS stream the next block has already started and OUT_DV shows how far into it you are. The clock that always reads N is the one INTEGRATING falls on - which is the useful thing to latch alongside the result, and here also the cheapest way to confirm at run time that the block was long enough for the tail. Only RESET clears it to 0.

Q formats link

IN and CV carry their own fixed point format (integer bits, fractional bits, sign), the same convention as the Fixed P. family - but remember that the IN scaling cancels out of the ratio and only its width matters here. The quotient is requantised into the CV format with the selected rounding (nearest / truncate) and overflow policy (saturate / wrap); saturation is symmetric for signed formats, as everywhere else in the toolchain - except for the two forced mean == 0 cases above, which ignore the Saturation property.

Sizing hints:

• a coefficient of variation is usually well under 1 for a well behaved signal, so the default 4 integer bits (up to ±7.99) is generous; raise it only if you expect the spread to dominate the mean;
• the fractional bits are where the resolution goes - the default 12 give steps of 1/4096, i.e. 0.024% - and each one costs exactly one clock of tail;
• keep the default SIGNED unless you know the mean is positive; an UNSIGNED format reports 0 for every negative-mean block.

Verification link

The core is regression tested by a host-side csim harness (tb/block-ops/run_tb.ps1) that runs one simulated clock at a time and follows OUT_DV. The expected values come from tb/block-ops/gen_golden.py, which evaluates $\sigma/\bar{x}$ in exact rational arithmetic and shares no algorithm with the core; the tolerance is exactly 1 LSB, never more. Coverage includes pseudo-random and sinusoidal inputs, a constant block (cv = 0), a zero-mean block (the forced saturation case), an all-zero block (the forced 0 case), a negative-mean block against both a SIGNED and an UNSIGNED output format, gain-scaled versions of the same signal (which is what pins the scale invariance), maximum positive and maximum negative samples, unsigned input, truncate instead of round, IN_DV gaps inside the accumulation, an EXP that changes half way through a block, and an EXP driven above Max Block Exponent to exercise the clamp. The tail length is checked against the formula at compile time: three copies of it exist - the BCF_TAIL macro in the core, tail_len() in the generator and TailClocks() in the plugin - and the testbench refuses to build if they disagree. The status outputs are checked clock by clock against the contract above.