How Do ISA Choices Shape Microarchitecture?

TL;DR

ISA complexity determines how work and optimization opportunities are divided between software and hardware designers. Instructions close to high-level languages reduce software mapping effort but increase hardware implementation freedom, while low-level primitives place more burden on compilers or assembly programmers and leave hardware designers fewer ways to optimize each operation.

Transcript

okay okay is everything good live stream can you hear me all good can you hear me how about that no can you hear me how but it's all green yeah okay okay good there's some delay maybe no that one e good okay let's start now I assume everything is working fine online audio video everything okay uh so welcome back uh looks like we have more people th... Read More

Key Insights

• A computer is a finite state machine whose control states dictate how instructions specified by the ISA are processed. The presented LC-3b state machine is one particular multicycle microarchitecture, not the only possible implementation of the architecture.
• The instruction processing cycle contains six identified steps, but not every instruction passes through all six. The required path depends on the instruction, and the microarchitecture controls that path through its states and associated operations.
• An ISA defines properties such as opcodes, data types, instruction formats, addressing modes, operation instructions, data-movement instructions, and control-flow instructions. Together, these features provide the mechanisms needed to construct assembly programs.
• Instruction complexity determines how much work one instruction performs. Complex instructions can represent substantial operations such as matrix multiplication or string copying, while simple instructions expose low-level primitives that can be combined to build more elaborate computations.
• The semantic gap is the distance between a high-level language and the ISA facilities used to express its constructs. Instructions, data types, and addressing modes that resemble high-level operations create a smaller semantic gap for software.
• A small semantic gap makes high-level constructs easier to map onto the ISA, reducing work for software designers. It simultaneously leaves hardware designers substantial freedom to choose among different implementations and latencies for operations such as matrix multiplication.
• A large semantic gap places more optimization responsibility on software, including compilers, assembly programmers, and potentially language models. Software must translate high-level constructs into sequences of primitive operations such as logical, shift, and control-flow instructions.
• Low-level primitive instructions limit the hardware designer's optimization room because operations such as AND, OR, NOT, and shifts have fewer fundamentally different implementation choices. Higher-level instructions provide a broader space for hardware-level implementation and optimization decisions.

Questions & Answers

Q: What is the relationship between an ISA and a microarchitecture?

An instruction set architecture specifies the instructions and related properties that software can use, including opcodes, data types, addressing modes, data movement, operations, and control flow. A microarchitecture is a particular hardware implementation of that specification. The LC-3b state machine is presented as one multicycle implementation, while a single-cycle microarchitecture offers a different implementation approach.

Q: What is the semantic gap in instruction set design?

The semantic gap is the distance between constructs in a high-level language and the instructions, data types, and addressing modes provided by an ISA. An ISA with operations closer to high-level language constructs has a smaller semantic gap. An ISA built from low-level primitives such as logical and shift operations has a larger gap that software must bridge.

Q: How does ISA complexity divide work between hardware and software?

An ISA close to high-level languages makes program constructs easier for software to map, so less translation work falls on compilers or assembly programmers. However, hardware designers must implement those richer operations and can choose among many possible designs. A primitive ISA reverses the balance by making software compose low-level operations while giving hardware less complex individual instructions to implement.

Q: Why can complex instructions create more hardware optimization opportunities?

Complex instructions describe substantial work, such as matrix multiplication, string copying, or key-value store access, without fixing every low-level implementation detail. That distance between the ISA operation and hardware control signals gives designers room to select different implementations and latencies. Primitive logical operations offer fewer distinct ways to optimize because their required work is already close to Boolean logic.

Q: What kinds of operations can complex ISA instructions represent?

Complex instructions can represent high-level operations that perform considerable work. Examples given in the lecture include matrix multiplication, string copying, and key-value store access. These operations are closer to constructs that software might directly request than primitive logical instructions are. Their implementation can therefore involve substantial hardware design choices hidden behind a single architectural instruction.

Q: How does a multicycle microarchitecture process instructions?

A multicycle microarchitecture uses a finite state machine to direct instruction processing through a sequence of states. The lecture identifies six steps in the instruction processing cycle while emphasizing that not every instruction uses every step. The LC-3b state diagram illustrates this approach, with different instruction classes following the states required to carry out their ISA-specified behavior.

Q: Why do simple instructions increase the compiler's responsibility?

Simple instructions perform limited, low-level work and are closer to hardware primitives such as AND, OR, NOT, and shift operations. High-level constructs must therefore be decomposed into sequences of these instructions. The optimization burden moves toward software, including the compiler or assembly programmer, which must choose an effective mapping from the source program to the available instruction sequence.

Q: Can an architecture include both simple and complex instructions?

An architecture can provide both simple and complex instructions, but including both does not eliminate complexity. The lecture notes that an ISA containing nearly everything still has to support the complex instructions and their implementation requirements. Consequently, architectures that combine many primitive operations with substantial high-level operations can still be regarded as complex instruction set architectures.

Summary & Key Takeaways

• The lecture completes the discussion of instruction set architectures before moving into microarchitecture. It reviews instruction types, formats, addressing modes, control flow, and the instruction processing cycle. The LC-3b state machine illustrates a multicycle implementation, while the upcoming single-cycle design provides another way to implement ISA-specified behavior in hardware.

• Instruction complexity is a fundamental ISA design choice. Complex instructions can perform substantial work, such as matrix multiplication, string copying, or key-value store access. Simple instructions instead expose low-level primitives closer to Boolean logic and hardware. An architecture that includes both many simple and complex operations can still be considered a complex ISA.

• The semantic gap describes the distance between high-level language constructs and the instructions, data types, and addressing modes supplied by an ISA. A smaller gap simplifies mapping for software but gives hardware designers more implementation responsibility. A larger gap shifts optimization toward compilers, assembly programmers, or other software that selects and combines primitive instructions.