Width Growth

Width Growth

The increase in the number of bits required to represent the possible result of repeated arithmetic operations.

Fixed-Width Register

A register with a finite number of bits and therefore a finite representable numeric range.

Repeated arithmetic can exceed the register's representable range.

What fundamental numeric problem can occur when many valid values are accumulated into fixed-width state?

Because the accumulated value represents the combined magnitude of many accepted inputs rather than only one input.

Why can an accumulator require more bits than each individual input?

Input Width

The number of bits used to represent one incoming value.

Accumulator Width

The number of bits allocated to store the retained running arithmetic result.

Input width is not automatically accumulator width.

What important width-design principle follows from repeated accumulation?

Because one WIDTH-bit sample may fit perfectly while the sum of many WIDTH-bit samples may require additional bits.

Why should accumulator width be considered separately from input width?

255

The maximum value of an 8-bit unsigned input.

510

The sum of two maximum 8-bit unsigned values, 255 + 255.

9 bits

The minimum number of unsigned bits required to represent 510.

1020

The sum of four maximum 8-bit unsigned values, 4 × 255.

10 bits

The minimum number of unsigned bits required to represent 1020.

N(2^WIDTH - 1)

The worst-case sum when accumulating N nonnegative WIDTH-bit values.

INPUT_WIDTH + ceil(log2(N))

An approximate safe accumulator-width planning rule for accumulating up to N nonnegative INPUT_WIDTH-bit values.

N

The maximum number of terms expected to accumulate before the arithmetic history is cleared or otherwise terminated.

ceil(log2(N))

The approximate number of additional accumulator bits required to accommodate the growth caused by accumulating N nonnegative values.

Because doubling the maximum number of accumulated terms can require approximately one additional result bit.

Why does the required accumulator width grow approximately with log2(N)?

Numeric Model

How the hardware interprets and handles values, including signedness, representable range, and behavior when that range is exceeded.

Signedness

Whether a bit pattern is interpreted as an unsigned value or as a signed value such as two's-complement.

Because signed and unsigned representations have different numeric ranges and therefore different accumulation requirements.

Why does signedness matter when choosing accumulator width?

Overflow

The condition in which the mathematical result cannot be represented within the available fixed-width arithmetic state.

Accumulator Overflow

Occurs when the mathematically correct running sum exceeds the numeric range representable by the Sum register.

Valid individual inputs do not guarantee a representable accumulated result.

Can accumulator overflow occur even when every input X is individually valid?

Because overflow depends on the magnitude of the accumulated history, not merely on whether each individual input fits its own input width.

Why can individually valid inputs still produce accumulator overflow?

Overflow Policy

The architectural decision defining what the machine should do when the mathematical result exceeds its available numeric state.

Wraparound

An overflow policy in which excess high-order information is discarded by fixed-width arithmetic.

Saturation

An overflow policy in which an out-of-range result is clamped to the maximum or minimum representable value.

Wider Storage

An overflow-management strategy that allocates additional state bits so a larger intended numeric range can be preserved.

Overflow/Status Reporting

An overflow strategy that retains a chosen fixed width while explicitly signaling that the representable range has been exceeded.

Wraparound, saturation, wider storage, and overflow/status reporting

Four architectural approaches identified in Part 05 for handling arithmetic results that outgrow the available state.

These overflow policies are not equivalent.

Is wraparound functionally interchangeable with saturation, wider storage, or overflow reporting?

Because each policy defines a different machine-level meaning for a mathematical result that exceeds the available numeric state.

Why is overflow behavior an architectural choice rather than merely an implementation detail?

Wraparound discards excess high-order information.

What happens to an accumulated result under wraparound overflow behavior?

Saturation preserves the nearest representable limit.

What happens to an accumulated result under saturation behavior?

Wider storage increases the range that can be represented before overflow occurs.

What is the purpose of increasing accumulator width?

Wider does not mean infinite.

Does increasing accumulator width permanently eliminate the possibility of range exhaustion?

Because every finite-width accumulator still has a finite representable range and sufficiently long or sufficiently large accumulation can eventually exceed it.

Why can even a wide accumulator eventually overflow?

Maximum Sample Count

One possible system requirement used to determine how much accumulator width is needed.

Algorithm Requirements

One possible source of the numeric-range requirement used to choose accumulator width.

Downstream Interface Width

A possible constraint on accumulator width because later hardware may accept only a particular result width.

FPGA Resource Constraints

A physical implementation consideration that may limit how much accumulator state is practical.

Acceptable Wrap/Saturation Policy

A system-level decision that can influence whether additional accumulator width is necessary.

ACC_WIDTH

A parameter used to separate the width of retained arithmetic state from the width of an individual input.

INPUT_WIDTH

The width of each incoming sample in a wide-accumulator architecture.

ACC_WIDTH may be greater than INPUT_WIDTH.

What width relationship allows an accumulator to retain a larger numeric history than one input word can represent?

Because repeated inputs can create a running total whose required range is much greater than the range of any one sample.

Why might ACC_WIDTH deliberately be chosen larger than INPUT_WIDTH?

Width Extension

The operation of representing a narrower value in a wider bit vector while preserving its intended numeric value.

Zero Extension

Widens an unsigned value by inserting zeros into the new high-order bit positions.

Sign Extension

Widens a two's-complement signed value by replicating its original sign bit into the new high-order positions.

Unsigned narrower operand → zero extension

Which extension rule preserves the numeric meaning of an unsigned input when entering a wider datapath?

Signed two's-complement narrower operand → sign extension

Which extension rule preserves the numeric meaning of a signed input when entering a wider datapath?

Because inserting zeros above an unsigned bit pattern preserves its original nonnegative numeric value.

Why is zero extension appropriate for an unsigned value?

Because replicating the sign bit preserves the two's-complement signed value when the representation is widened.

Why is sign extension necessary for a signed two's-complement value?

Extension preserves numeric interpretation while changing representation width.

What is the architectural purpose of width extension?

Width extension is not padding for appearance.

Is width extension merely cosmetic bit padding?

Because the narrower value must enter a wider arithmetic datapath without changing the value that its bit pattern is intended to represent.

Why must the correct extension rule be chosen before wide accumulation?

A datapath can perform every addition correctly at the bit level and still fail the system's numeric intent because its state register was sized too narrowly.

What central design warning does Part 05 make about accumulator width?