DSP - BLOCK MIN MAX

Introduction link

The Block Min Max block chops the input stream into consecutive blocks of N samples and, at the end of each block, publishes the extremes of that block:

$$ \mathrm{MIN} = \min_{0 \le i < N} x_i , \qquad \mathrm{MAX} = \max_{0 \le i < N} x_i $$

$$ \mathrm{PEAK_TO_PEAK} = \mathrm{MAX} - \mathrm{MIN} $$

and, optionally, where in the block they happened:

$$ \mathrm{ARGMIN} = \min {, i : x_i = \mathrm{MIN} ,} , \qquad \mathrm{ARGMAX} = \min {, i : x_i = \mathrm{MAX} ,} $$

That is the whole block. Two comparators, two registers, and one subtraction at the end if you ask for the span.

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

N being a power of two is what makes every division in this family an exact arithmetic shift. This particular block divides by nothing at all, so it simply inherits the free runtime block length: the block size can be changed while the design is running, for free.

What each output is FOR link

• MIN and MAX - amplitude and headroom at a glance. They are the classic clipping / saturation check: a MAX pinned at full scale, block after block, is an input that is being driven too hard.
• PEAK_TO_PEAK - the span of the block in one number, which is the useful form for a level meter, a noise-band estimate or a “is anything happening” test. It costs one subtraction and no extra clock.
• ARGMIN / ARGMAX - where in time the extremum happened. This is what locates a pulse inside the block: the index of the maximum is a coarse time stamp, and the distance between ARGMIN and ARGMAX measures a pulse’s rise or fall span.

Cost link

Two comparators and two registers for the running minimum and maximum, plus two more registers only if ARGMIN or ARGMAX is enabled, plus one subtraction and one requantiser if PEAK_TO_PEAK is enabled. No multiplier, no divider, no square root, no serial tail arithmetic. It is the cheapest non-trivial block of the family.

When to use this instead of Block Statistics link

The all-in-one Block Statistics block is not deprecated and computes these same five numbers among twenty other statistics. The rule is simple:

• you want several statistics of the SAME block - min/max and mean and RMS of the same N samples - use Block Statistics. They share one accumulator and one serial tail, so the second and third statistic are nearly free.
• you want exactly these numbers - use this block. Then you synthesise only them: the pin list, the logic and the tail are all that the extremes need, and nothing else reaches the synthesiser.

Two Block Statistics blocks side by side would duplicate the accumulators; two per-operator blocks side by side duplicate them too. One Block Statistics block never does.

Pin Description link

Properties link

Accuracy link

MIN and MAX are actual samples of the block, copied out unchanged, so there is no error in them at all - not even a requantisation, because they are returned in the input format. ARGMIN and ARGMAX are plain indices. PEAK_TO_PEAK is one exact integer subtraction, and its only error is the single requantisation into the Q format you chose for it.

That is not an aspiration. The host regression (tb/block-ops/run_tb.ps1) demands tolerance ZERO against a Python golden (tb/block-ops/ gen_golden.py) that evaluates the definitions above in exact rational arithmetic - not “within 1 LSB”, not “within a few counts”. Any deviation at all fails the build.

MIN and MAX have no Q format, and why link

MIN and MAX are returned in the input Q format and have no format property of their own. They are samples: no other format makes sense for them, and there is nothing to requantise. Only PEAK_TO_PEAK gets its own format, because $\mathrm{MAX} - \mathrm{MIN}$ needs one bit more than a sample and can be rescaled or clipped like any other derived quantity - which is why its default format is 17 bits next to a 16 bit input default, and UNSIGNED, since the span is never negative.

A direct consequence: on this block the Rounding and Saturation properties only ever affect PEAK_TO_PEAK. Nothing else here is requantised.

Ties: ARGMIN and ARGMAX report the FIRST occurrence link

If the minimum (or the maximum) occurs more than once in a block, the reported index is the first one. The comparisons in the core are STRICT (< and >, never <= / >=), so a later equal sample never moves the index. A block of identical samples therefore reports index 0 for both.

The index pins are $\max(\textit{Max Block Exponent},\ 2)$ bits wide, which covers every position of the longest block the block is sized for. If the runtime EXP is smaller than Max Block Exponent the unused high bits simply read 0 - the width follows the property, not the runtime exponent.

Accumulation and IN_DV link

IN_DV is the only qualifier. It says “this clock carries a sample”: a sample is compared against the running extremes, 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 become a spurious MIN or MAX - while the 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.

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 - a block that only accepts samples on IN_DV has no need to be frozen.

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. You can sweep EXP from a register interface while the stream runs and every result stays self-consistent - including the indices, which are always indices into the block that was actually measured.

Timing: the latency contract link

OUT_DV pulses for one clock, L clocks after the clock on which the N-th sample of the block was accepted - not when that sample arrives. Every enabled output is updated on that same clock and on no other. For this block

$$ L = 2 $$

and it is a constant: there is no serial arithmetic here at all, so L does not depend on the input width, on the output width, on EXP, or on which outputs you enabled. The two clocks are one to enter the final state and one to present the registered result.

All the outputs are written in that same final state, so PEAK_TO_PEAK costs one subtraction, not a clock: enabling it - or the two index pins - cannot lengthen L.

The rule that governs the whole family is that the tail of one block must finish before the next block completes, i.e.

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

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

With $L = 2$ that condition is $2^{\mathrm{EXP}} \ge 2$, i.e. EXP $\ge$ 1, so it cannot bite here: the only value that violates it is EXP = 0, a block of a single sample. The blocks where this rule really matters are the ones with a serial tail - Block RMS, Block Variance, Block Std Dev and Block Crest Factor, whose L runs to tens of clocks and whose minimum usable exponent the compiler prints in the compilation log.

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

Three optional status outputs, all defaulting to NO. They answer different questions:

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 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 on the OUT_DV clock it reads the length of the block being presented - which is the useful thing to latch alongside the results. Only RESET clears it to 0.

Q formats link

IN and PEAK_TO_PEAK carry their own fixed point format (integer bits, fractional bits, sign), the same convention as the Fixed P. family. PEAK_TO_PEAK is requantised into its format with the selected rounding (nearest / truncate) and overflow policy (saturate / wrap); saturation is symmetric for signed formats, as everywhere else in the toolchain.

Sizing is easy here:

• MIN and MAX are samples and come out in the input format - there is nothing to size.
• PEAK_TO_PEAK can reach the full input span, so give it one integer bit more than the input if you want it never to clip. The default 17-bit unsigned format is exactly that for the default 16-bit signed input.
• ARGMIN and ARGMAX are unsigned indices with no Q format; their width follows Max Block Exponent.

Enabling and disabling outputs link

Each output group has its own enable, and MIN and MAX share one - they come from the same pair of comparators, so there is nothing to save by taking only one of them. Turning a group off removes the pin and all of its logic before synthesis (the enables are preprocessor switches on the HLS core, so nothing reaches the synthesiser at all) and it also removes the port from the generated entity, which is why the enables take part in the IP’s unique name.

There are no hidden internal dependencies to reason about: the min/max registers exist in every configuration, because every output of this block is derived from them. At least one output must be enabled - the property window refuses a configuration in which MIN/MAX, PEAK_TO_PEAK, ARGMIN and ARGMAX are all off, since that would leave an entity with no data ports at all.

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 the definitions above in exact rational arithmetic and shares no algorithm with the core; the tolerance is 0. Min/max coverage includes pseudo-random input, a constant block (every sample a tie, so both indices must read 0), a ramp (whose minimum and maximum are the first and the last sample), an extremes stimulus into a PEAK_TO_PEAK-only configuration, unsigned input, an EXP that changes half way through a block, and the enable subsets MIN/MAX only, ARGMAX only and PEAK_TO_PEAK only - which is also what proves the pin list and the entity port list agree for those combinations. The status outputs are checked clock by clock against the contract above. A cross-check compiles this core and the all-in-one block_stats.cpp into the same binary, drives them with identical stimulus, and compares the two clock by clock.