Arithmetic State

Arithmetic State

A retained arithmetic result that participates in a future computation.

Stateful Arithmetic

Arithmetic in which a previously computed result is stored and used as part of a later arithmetic operation.

Ordinary Combinational Addition

Produces a result from the present operands without depending on the result of an earlier calculation.

Accumulation

A stateful arithmetic process in which a previously stored Sum is combined with new input data to produce the next Sum.

Accumulator

A stateful arithmetic structure that repeatedly adds accepted input values into a retained running Sum.

Sum_next = Sum_current + X

The fundamental next-state equation of an enabled accumulator.

Sum_current

The previously accumulated arithmetic state that becomes one operand of the next addition.

X

The new input value that may be incorporated into the accumulated history.

Sum_next

The updated accumulated state produced by adding X to the previous Sum.

Running Sum

The accumulated total of the sequence of input values accepted so far.

Arithmetic History

The interpretation of the current Sum as a numerical summary of previously accepted inputs.

Because the current Sum depends on values accepted during earlier clock cycles, not merely on the present X.

Why can an accumulator's Sum be described as arithmetic history?

If the accepted sequence is X0, X1, X2, …

After successive enabled updates, Sum represents X0 + X1 + X2 + … subject to the accumulator's fixed-width arithmetic behavior.

reset: Sum = 0 → accept X0: Sum = X0 → accept X1: Sum = X0 + X1 → accept X2: Sum = X0 + X1 + X2

The basic progression of arithmetic history through an accumulator.

Feedback

The architectural connection through which the stored Sum is returned as an operand of the adder that computes the next Sum.

Feedback Datapath

An arithmetic structure in which a stored result is fed back into the logic responsible for calculating its next value.

Adder + Sum Register

The two essential datapath elements of a minimal accumulator.

Adder

Computes Sum + X from the current stored arithmetic state and the new input.

Sum Register

Retains the accumulated result across clock cycles and feeds that result back into the next addition.

Because the register separates the current Sum from the next Sum across clock edges, preventing the feedback path from becoming an uncontrolled combinational loop.

Why must the accumulator's arithmetic feedback pass through a clocked register?

An accumulator does not merely store the latest answer.

Is it true that an accumulator is simply a register that remembers the most recent independent addition result?

Because its stored answer becomes an operand that changes the next answer.

Why is an accumulator fundamentally different from merely storing the output of an independent arithmetic operation?

Arithmetic state = remembered information used as arithmetic input.

How does accumulation apply the general concept of state specifically to arithmetic?

Accumulator Module

The project's WIDTH-bit running-sum machine that adds X into Sum only on enabled rising clock edges.

parameter WIDTH = 8

Sets the bit width of X and Sum in the project's basic Accumulator.

input wire clk

Provides the clock whose rising edge determines when accumulator state may update.

input wire reset

Control input that establishes the accumulator's Sum at a known initial value.

input wire enable

Control input that determines whether the current rising clock edge accepts X into the accumulated history.

input wire [WIDTH - 1:0] X

The WIDTH-bit value presented as the new possible contribution to the running Sum.

output reg [WIDTH - 1:0] Sum

The WIDTH-bit register holding the accumulator's persistent arithmetic state and output.

always @(posedge clk)

Implements the clocked sequential behavior of the Accumulator.

if (reset)

The highest-priority accumulator condition that clears the retained arithmetic history.

Sum <= {WIDTH{1'b0}};

Clears every bit of the WIDTH-bit Sum register to zero.

{WIDTH{1'b0}}

A parameterized Verilog replication expression that produces WIDTH zero bits.

Zero

The additive origin established for Sum when the accumulator is reset.

Because every future accumulated value depends on the previous Sum, so accumulation must begin from a known arithmetic state.

Why is reset particularly important in an accumulator?

if (enable)

Determines whether X becomes part of the accumulator's arithmetic history on the current rising clock edge.

Sum <= Sum + X;

Updates the retained Sum by adding the current input X to the previously stored Sum.

enable = 1

On the rising clock edge, the accumulator accepts X and updates Sum to Sum + X.

enable = 0

On the rising clock edge, the accumulator retains its previous Sum and X does not become part of the accumulated history.

Because a clock edge should not automatically imply that the current X is intended to become part of the running total.

Why does the Accumulator require an enable signal?

Controlled Accumulation Event

A rising clock edge on which enable is asserted and X is therefore incorporated into Sum.

Enable Turns Arithmetic Into a Controlled Event

The principle that enable determines which clock edges are allowed to modify the accumulator's arithmetic history.

No assignment to Sum when enable = 0

The RTL behavior that causes the clocked Sum register to retain its previous value when accumulation is disabled.

Because Sum is a register and a clocked register retains its existing state when no assignment updates it on that clock edge.

Why does the Accumulator not require an explicit Sum <= Sum statement when enable is 0?

Reset has priority over enable.

What happens if reset and enable are both asserted on the same rising clock edge?

Because the reset condition is tested before the enable condition in the clocked procedural block.

Why does reset take priority over accumulation?

Nonblocking Assignment (<=)

The assignment style used to update Sum because Sum represents clocked sequential state.

Sum is both output and feedback state.

What two architectural roles does Sum perform in the Accumulator?

As an output, Sum exposes the current running total; as feedback state, its current value becomes an operand in the next enabled addition.

How can Sum simultaneously serve as the accumulator's output and part of its datapath?

Current Sum + new X → next Sum

The fundamental dataflow through the accumulator's feedback datapath.

The adder performs the arithmetic; the register gives the arithmetic memory; enable decides which clock edges enter that memory.

The central architectural interpretation of the basic Accumulator.