DSP - BLOCK SNR

Introduction link

The Block SNR block chops the input stream into consecutive blocks of N samples and, at the end of each block, publishes the signal to noise ratio 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{SNR} = \frac{\bar{x}}{\sigma} $$

The mean is the signal and the standard deviation is the noise. That is the right model for a DC-ish measurement corrupted by additive noise: a photodiode current, a detector baseline, an ADC reading a voltage reference, a regulated rail. It is not the right model for a modulated carrier, where the signal is the AC part - there, RMS of the band of interest over RMS of the rest is the number you want, and this block is not it.

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}}$:

THIS IS A LINEAR RATIO, NOT DECIBELS link

SNR = 100 means the mean is a hundred times the standard deviation. It does not mean 100 dB. A logarithm is not cheap in fixed point and it is not this block’s job; take $20\log_{10}(\mathrm{SNR})$ downstream - in a CPU, or in a log block - if you want dB. Nothing in this core is approximated to make that conversion easier.

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$:

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

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

Block SNR or Block Coefficient of Variation? link

Block Coefficient of Variation computes $\sigma/\bar{x}$ - 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 is snr = 1000, which needs 10 integer bits here and would be four LSBs of a Q4.12 CV - use this block. A noisy or nearly zero-mean channel has snr near 0 and cv around 1 - use the other one. The two cost exactly the same tail for the same number of output fractional bits, so the choice is purely about where your numbers live.

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.

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 SNR pin. So:

• you want several statistics of the SAME block and the SNR - 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’ MEAN by its STDDEV 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 SNR 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{IN_SW} + \mathit{MaxBlockExponent} + \mathrm{SNR_{fract}} + 4,; \mathrm{SNR\ width} + 2\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{SNR_{fract}} + \mathrm{EXP} + 13 $$

which is the same formula Block Coefficient of Variation has, with its CV_BitsFract in place of SNR_BitsFract. The two blocks cost the same.

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 denominator known to full internal precision whatever the output format is, 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 SNR format (Q8.8 signed):

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

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. That is rarely a real restriction here: an SNR measured over 128 samples is already a poor estimate, and you will normally want thousands.

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 sigma is zero link

sigma == 0 is a real case, and it is not an error: a constant block has no noise at all, and so does a block that a long integration has smoothed below one internal LSB. The core detects it on the denominator (the root came out 0) and forces the answer:

All three forced cases ignore the Saturation property, because none of them is a requantisation overflow - they are the definition of the ratio breaking down. Note the middle row in particular: a constant $-5$ block has SNR $-\infty$, not $+\infty$, and with an UNSIGNED output format it reports 0 rather than the maximum.

In practice a zero root on a signal that is not constant means your block really is that quiet at the resolution of the input - the honest answer is “the noise is below one LSB”, and saturating is the right way to say it.

Signed by default, and on purpose link

$\sigma$ is non negative but the mean is not, so SNR 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. UNSIGNED buys one bit, which here is one doubling of the SNR you can report.

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 denominator root is taken at full internal precision, with $\mathrm{SQG} = 4$ guard bits; the numerator $|S_1|$ is shifted left by the same $\mathrm{SQG}$ plus $\mathrm{SNR_{fract}}$, so the guard bits cancel in the quotient and the divider delivers the answer already at the output resolution. The root is up to 1 ulp low at $2^{-\mathrm{SQG}}$ of an SNR LSB and the quotient is floored, so

SNR is accurate to within 1 LSB - provided the root is not tiny.

A block whose root is only a few ulps (a nearly constant signal) has a genuinely ill-conditioned ratio: a one-ulp error in a three-ulp denominator is a 33% error in the answer, and no amount of output bits fixes it. That is the arithmetic being honest, not a defect. The host regression enforces the 1 LSB bound and its scenarios keep the root away from 0; the sigma == 0 corner is covered separately, by the forced cases above.

Because the quotient already sits at the output resolution, the final requantisation has nothing left to shift: it only applies the sign and saturates. That makes the Rounding property effectively a no-op on this block (see its description).

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, and in particular cannot fake noise that is not there - 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, SNR values taken at different EXP are directly comparable as estimates of the same quantity - though a longer block always gives a better estimate of it, since $\sigma$ itself is measured from more samples. 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 (it tells you how many samples the estimate rests on), 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 SNR 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 SNR format with the selected overflow policy (saturate / wrap); saturation is symmetric for signed formats, as everywhere else in the toolchain - except for the forced sigma == 0 cases above, which ignore the Saturation property.

Sizing hints:

• the integer bits set the largest ratio you can report: the default 8 (signed) reach ±127.99, i.e. about 42 dB. If you are measuring a clean reference at 60 dB you need 10 integer bits, at 80 dB you need 14 - and they are free in tail clocks;
• the fractional bits are the resolution: the default 8 give steps of 1/256, which is 0.03 dB at snr = 1 and about 0.0002 dB at snr = 100. Near the top of the range you need very few of them - each one costs one clock of tail, so do not be generous without a reason;
• keep the default SIGNED unless you know the mean is positive; an UNSIGNED format reports 0 for every negative-mean block, including the constant-negative one that would otherwise saturate to the minimum.

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 $\bar{x}/\sigma$ in exact rational arithmetic and shares no algorithm with the core; the tolerance is exactly 1 LSB, never more, and the scenarios keep the root away from zero so that the bound is meaningful. Coverage includes pseudo-random and sinusoidal inputs on a DC pedestal, a constant positive block and a constant negative block (the forced saturation cases, which is what pins “the saturation keeps the sign of the mean”), 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 pins the scale invariance), maximum positive and maximum negative samples, unsigned input, 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 BSN_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.