Global Control and Execute Decoding

Global Control

The system-level control layer that remembers user intent and exposes that intent to the integrated arithmetic engine.

Global Control State

Persistent control information describing the user's currently selected operation and interpretation mode.

Operation

The 4-bit global control state identifying which arithmetic function is currently selected.

SignedMode

The global control state specifying whether compatible arithmetic units interpret operands as signed or unsigned.

ExecutePulse

The system-level execution event indicating that the user has requested execution of the currently selected operation.

NextOperationPulse → Operation

What command-to-state relationship changes which arithmetic operation is selected?

SignedModePulse → SignedMode

What command-to-state relationship changes numeric interpretation?

ExecuteButtonPulse → ExecutePulse

What command-to-event relationship produces the system-level execution request?

Selection Intent

Operation represents which arithmetic behavior the user currently wants selected.

Interpretation Intent

SignedMode represents how compatible operand bit patterns should be numerically interpreted.

Execution Intent

ExecutePulse represents the user's request for the selected stateful or transactional behavior to act.

Operation + SignedMode + ExecutePulse

What three signals form the main global-control interface exported by ArithmeticEngineControl?

The input subsystem creates trustworthy events; the control subsystem turns those events into remembered intent and execution intent.

How does the responsibility of global control differ from the input subsystem?

The global controller should answer WHAT the user wants, not HOW every arithmetic algorithm proceeds cycle by cycle.

What is the proper abstraction level of ArithmeticEngineControl?

Global Intent

The high-level specification of which operation is selected, which interpretation mode applies, and whether execution was requested.

Local Action

A control signal directed toward a particular arithmetic unit, such as START or enable.

Global intent → local action

What control transformation occurs between ArithmeticEngineControl and the stateful arithmetic modules?

Execute Decoding

The combinational process of combining ExecutePulse with Operation to determine which stateful arithmetic unit should receive a local action.

Operation identifies the destination of the execution request.

What role does Operation play when ExecutePulse is decoded?

ExecutePulse identifies that an execution request exists now.

What role does ExecutePulse play when generating local START/enable signals?

Operation answers WHICH unit; ExecutePulse answers WHETHER execution is requested now.

What compact distinction explains their cooperation during execute decoding?

ExecutePulse && (Operation == ACCUMULATE_OPERATION)

What condition generates AccumulatorEnable?

ExecutePulse && (Operation == WIDE_ACCUMULATE_OPERATION)

What condition generates WideAccumulatorEnable?

ExecutePulse && (Operation == MAC_OPERATION)

What condition generates MACEnable?

ExecutePulse && (Operation == SEQUENTIAL_MULTIPLY) && ~SequentialMultiplyBusy

What condition generates SequentialMultiplyStart?

ExecutePulse && (Operation == DIVIDE_OPERATION) && ~DividerBusy

What condition generates DividerStart?

AccumulatorEnable

Which local action signal is sent to AccumulatorUnit?

WideAccumulatorEnable

Which local action signal is sent to WideAccumulatorUnit?

MACEnable

Which local action signal is sent to MACUnit?

SequentialMultiplyStart

Which local transaction-start signal is sent to SequentialMultiplyUnit?

DividerStart

Which local transaction-start signal is sent to DividerUnit?

ExecutePulse → operation decode → one appropriate local action

What is the conceptual path of an execution request through topModule?

Local Control Decoding

Logic that translates high-level global control information into commands understood by individual functional units.

topModule

Where is ExecutePulse decoded into AccumulatorEnable, WideAccumulatorEnable, MACEnable, SequentialMultiplyStart, and DividerStart?

ArithmeticEngineControl produces global intent; topModule performs operation-specific local decoding.

How are control responsibilities divided between ArithmeticEngineControl and topModule?

The arithmetic modules receive control signals expressed in terms of their own interfaces rather than raw button events.

What abstraction benefit results from execute decoding?

The accumulator receives enable, not btnU.

How does the accumulator demonstrate separation between physical user input and local arithmetic control?

The sequential multiplier receives START, not ExecuteButtonPulse or the raw execute button.

How does the sequential multiplier demonstrate control abstraction?

The divider receives START, not knowledge of how the user generated the execute request.

How does the divider demonstrate user-interface decoupling?

Command Translation

The conversion of one high-level user action into the particular control vocabulary required by a selected subsystem.

One conceptual Execute action can become enable, START, or no state-changing command depending on the selected operation.

Why is command translation necessary in the integrated arithmetic engine?

Local Enable

A control signal authorizing a stateful unit to update its stored state on an appropriate clock edge.

Local START

A control event requesting that a transactional multi-cycle unit begin a new operation.

Enable typically authorizes a direct state update; START launches a transaction that then unfolds over multiple cycles.

What is the architectural distinction between an enable and START in this engine?

Accumulator, WideAccumulator, and MAC.

Which integrated arithmetic units use execute-derived enable signals?

Sequential multiplier and divider.

Which integrated arithmetic units use execute-derived START signals?

The selected unit's interface and temporal behavior.

What determines whether ExecutePulse is translated into an enable or a START request?

Execute Routing

Directing one system-level execute event toward the arithmetic resource selected by Operation.

Only the selected stateful operation should receive the corresponding local execution action.

What is the key routing rule for ExecutePulse?

No accumulator enable should be generated.

If ExecutePulse is high while Operation selects MAC, what should happen to AccumulatorEnable?

MACEnable becomes asserted.

If ExecutePulse is high while Operation selects MAC, which local action should be generated?

WideAccumulatorEnable becomes asserted.

If ExecutePulse occurs while WIDE_ACCUMULATE_OPERATION is selected, which local state update is authorized?

SequentialMultiplyStart may be asserted if the sequential multiplier is not busy.

If ExecutePulse occurs while SEQUENTIAL_MULTIPLY is selected, what local request can be generated?

DividerStart may be asserted if the divider is not busy.

If ExecutePulse occurs while DIVIDE_OPERATION is selected, what local request can be generated?

No local stateful execution signal is generated by those decode equations.

If ExecutePulse occurs while COMPARE_OPERATION is selected, what happens to the accumulator/MAC/multiplier/divider local action signals?

No execute-derived update is required for the combinational calculation itself.

Why does a combinational operation not need an enable merely to produce its current output?

Its combinational output already reflects the current operands and relevant mode/control inputs.

Why can an adder, comparator, or combinational multiplier produce a result without ExecutePulse?

ExecutePulse is primarily significant when an operation must modify remembered state or launch a multi-cycle transaction.

For which integrated operation families is ExecutePulse architecturally essential?

Combinational Availability

A combinational functional unit's result can exist continuously whenever its inputs establish a value.

Stateful Authorization

A stateful functional unit changes remembered information only when the appropriate control condition permits it.

Transaction Launch

A START event requests that a multi-cycle unit begin internally sequenced work.

Availability is not authorization.

What important distinction explains why many combinational results can exist while only selected stateful units update?

A result may be electrically available even though no state-changing action has been requested.

What does the integrated engine demonstrate about result existence versus execution?

Execution does not necessarily mean "begin computing" for every type of arithmetic hardware.

Why should ExecutePulse not be interpreted identically for every functional unit?

For stateful units it can authorize change; for iterative units it can launch a transaction; purely combinational units already calculate continuously.

How does the meaning of the user's Execute action differ across arithmetic families?

Uniform User Intent

The user experiences one conceptual Execute command even though different hardware units respond to it differently.

Heterogeneous Hardware Response

Different arithmetic units translate the same global execution concept into different local behaviors.

One user-interface concept can hide several implementation-specific control mechanisms.

What architectural advantage comes from a common Execute action?

The user does not need a separate physical execute button for accumulators, multipliers, and dividers.

How does global execution intent simplify the physical interface?

The top-level integration layer translates the common request into unit-specific control.

What allows one Execute button to work with heterogeneous arithmetic units?

Control Decoding Boundary

The point where generic global intent becomes control specific to individual arithmetic modules.

ExecutePulse + Operation

What information crosses into the execute-decoding decision?

AccumulatorEnable, WideAccumulatorEnable, MACEnable, SequentialMultiplyStart, and DividerStart.

What signals emerge from execute decoding toward the stateful datapath?

The global controller remains independent of the exact local signal names and internal algorithms of the arithmetic units.

Why is it useful to place local decoding outside ArithmeticEngineControl?

It prevents ArithmeticEngineControl from becoming an enormous universal controller for every arithmetic algorithm.

What architectural problem does hierarchical control avoid?

Hierarchical Control

The organization of control into layers where higher levels express intent and lower levels manage specialized actions or sequencing.

Global Controller

The control layer that identifies what operation and interpretation the user wants and whether execution was requested.

Local Controller

The specialized control logic that determines how a multi-cycle operation progresses internally over time.

Global controller = WHAT; local controller = HOW OVER TIME.

What compact distinction separates global and local control?

ArithmeticEngineControl.

Which module owns the global "what does the user want?" question?

The sequential multiplier's local controller.

Which control layer owns the cycle-by-cycle progression of sequential multiplication?

The divider's local controller.

Which control layer owns the cycle-by-cycle progression of division?

The global controller does not need to know every LOAD/RUN/DONE detail inside an iterative arithmetic engine.

What information is intentionally hidden from ArithmeticEngineControl?

START acts as the handoff from global execution intent to local transaction sequencing.

What architectural role does START play between global and local control?

Global request → legal START → local controller → multi-cycle datapath

What control hierarchy describes execution of an iterative arithmetic operation?

The global layer decides that division should begin; the local divider controller determines how division proceeds.

How does division illustrate hierarchical control?

The global layer decides that sequential multiplication should begin; the multiplier controller sequences the actual iterative algorithm.

How does sequential multiplication illustrate hierarchical control?

Local Temporal Ownership

The principle that the subsystem performing a multi-cycle algorithm owns the detailed timing sequence of that algorithm.

Because the local controller is closest to the internal state and progress conditions of its datapath.

Why should detailed multi-cycle sequencing remain local?

It reduces coupling between top-level integration logic and arithmetic implementation details.

What architectural benefit results from local temporal ownership?

The multiplier algorithm can evolve internally while preserving its START/BUSY/DONE interface.

How can local control improve maintainability?

The top level can reason about a transaction without manipulating the multiplier's internal cycle state directly.

How does local control improve abstraction?

Busy Guard

A condition that prevents a new START request from being issued to a transactional unit while that unit is already occupied.

~SequentialMultiplyBusy

What busy guard appears in the SequentialMultiplyStart equation?

~DividerBusy

What busy guard appears in the DividerStart equation?

It prevents a new sequential multiplication transaction from being launched while the existing one is still active.

Why is ~SequentialMultiplyBusy included in the START equation?

It prevents a new division transaction from being launched while the divider is still processing the previous one.

Why is ~DividerBusy included in the START equation?

Request Qualification

The process of allowing a requested action only when additional legality conditions are satisfied.

ExecutePulse alone is not sufficient to start a sequential multiplier.

Why is ExecutePulse by itself insufficient for SequentialMultiplyStart?

The correct operation must be selected and the unit must not be busy.

What additional conditions qualify ExecutePulse before sequential multiplication can start?