Read the original article here.

---

Understanding the Microprocessor: The Core of Computing

In the journey to understand "The Lost Art of Building a Computer from Scratch," the microprocessor stands out as the single most important component. It is the "brain" of the computer, performing all the calculations and coordinating operations. Before the advent of the microprocessor, building a computer required racks of circuit boards filled with thousands of individual components. The microprocessor revolutionized computing by integrating the essential functions of a Central Processing Unit (CPU) onto a single or a few chips. This resource will delve into what a microprocessor is, how it works, its structure, its historical evolution, and its various forms, providing the foundational knowledge necessary for anyone interested in the low-level workings of computers.

What is a Microprocessor?

At its heart, a microprocessor is a complex digital circuit designed to execute instructions.

A microprocessor is a computer processor where the data processing logic and control circuitry are contained on a single integrated circuit (IC), or a very small number of ICs. It contains the Arithmetic Logic Unit (ALU), control logic, and registers needed to perform the functions of a computer's Central Processing Unit (CPU).

Essentially, it's a CPU crammed onto a small chip. This integration, made possible by advanced manufacturing techniques like Very-Large-Scale Integration (VLSI), drastically reduced the size, cost, and power consumption of computers compared to their predecessors built with discrete components or many smaller integrated circuits (ICs). For someone building a computer from scratch, understanding the microprocessor means understanding the core engine that drives the entire system.

Core Components and Operation

A microprocessor, even a minimal one, contains fundamental blocks necessary for computation:

1. Arithmetic Logic Unit (ALU): This is the part that performs arithmetic (like addition and subtraction) and logic operations (like AND, OR, NOT).

   An Arithmetic Logic Unit (ALU) is a digital circuit within the microprocessor that performs arithmetic operations (addition, subtraction, multiplication, division - although some early ALUs only did add/subtract) and logic operations (Boolean logic like AND, OR, NOT, XOR).

   The ALU takes binary data as input, performs an operation, and produces a binary result. It also typically sets "flags" in a status register to indicate properties of the result, such as whether it was zero, negative, or if an overflow occurred.

2. Control Logic (or Control Unit): This is the "director" of the microprocessor. It fetches instructions from memory, decodes them, and generates control signals that tell other parts of the processor (like the ALU, registers, and memory interface) what to do in the correct sequence to execute the instruction.

   Control Logic (or Control Unit) is a component of the microprocessor that manages and coordinates the operations of other components. It retrieves instructions from memory, interprets them (decodes), and issues control signals to execute the instruction.

3. Registers: These are small, high-speed storage locations directly within the microprocessor. They hold data that the ALU is currently processing, instruction addresses, and other temporary values. Registers are crucial because accessing data in memory is much slower than accessing data in registers.

   Registers are small, very fast memory storage locations built directly into the microprocessor. They are used to hold data operands for the ALU, instruction pointers (program counter), temporary results, and status flags.

4. Memory Interface: The microprocessor needs to communicate with external memory (RAM and ROM) to fetch instructions and data, and to store results. The memory interface handles these communication signals (address, data, control).

5. Input/Output (I/O) Interface: This allows the microprocessor to communicate with peripheral devices, such as keyboards, displays, storage drives, and network interfaces.

How it Works: The Instruction Cycle

The fundamental operation of a microprocessor can be simplified into a cycle:

1. Fetch: The control unit retrieves the next instruction from memory, using the program counter register to know where to look.
2. Decode: The control unit interprets the instruction to determine what operation needs to be performed (e.g., add two numbers, move data).
3. Execute: The control unit directs the appropriate components (e.g., the ALU and registers) to perform the specified operation. This might involve reading data from registers, performing an ALU operation, writing a result back to a register or memory, or jumping to a new instruction address.

This cycle repeats billions of times per second in modern microprocessors, driven by an internal or external clock signal.

A clock-driven system (like a microprocessor) uses a rhythmic pulse signal (the clock) to synchronize all operations. Each operation or group of operations is typically completed within one or more clock cycles. Faster clock speeds generally mean more operations per second.

Microprocessors operate on data represented in the binary number system (0s and 1s) and perform operations based on Boolean logic.

Boolean Logic is a system of logic dealing with binary values (true/false, 1/0) and logical operations (AND, OR, NOT). It forms the basis of how digital circuits within a microprocessor make decisions and perform operations.

The Evolution of the Microprocessor

The development of the microprocessor was a pivotal moment in computing history.

Before the Microprocessor: Early computers and even "mini-computers" of the 1960s were built using many individual integrated circuits, often mounted on multiple circuit boards. These ICs performed simpler functions (like gates, flip-flops, adders) at Medium-Scale Integration (MSI) or Small-Scale Integration (SSI) levels. Building a CPU this way was complex, costly, and less reliable due to the vast number of connections.

The Breakthrough: Integration: The key innovation of the microprocessor was integrating the entire CPU function onto one or a few chips. This was made possible by advancements in semiconductor manufacturing, particularly:

Metal–Oxide–Semiconductor (MOS) technology is a fabrication process for integrated circuits that allowed for much higher transistor density on a single chip compared to earlier technologies like bipolar or TTL.

Very-Large-Scale Integration (VLSI) is the process of creating integrated circuits that contain hundreds of thousands or millions of transistors on a single chip. The development of VLSI was essential for putting a complete CPU onto one chip.

This dense integration led to:

• Reduced Cost: Mass production via highly automated processes lowered the per-unit price.
• Increased Reliability: Fewer physical connections between chips meant fewer points of failure.
• Smaller Size: Allowed computers to shrink dramatically.

The growth in complexity and density of ICs generally followed trends like Moore's Law (transistor count doubling roughly every two years) and Rock's Law (the cost of a semiconductor fabrication plant doubling every four years, implying the cost of manufacturing a specific chip size stays relatively constant as component size shrinks).

Historical Milestones and Early Microprocessors

The "invention" of the microprocessor is subject to some debate, with several projects occurring concurrently. However, the Intel 4004 is widely recognized as the first commercially available single-chip microprocessor.

• Early Contenders (Late 1960s/Early 1970s):

  • Four-Phase Systems AL1 (1969): An 8-bit bit-slice chip used as part of a multi-chip CPU for their System IV/70 computer. While functionally a part of a CPU on a chip, it wasn't a single-chip CPU itself initially, though a single-chip demonstration was later built.
  • Garrett AiResearch CADC (1970): Developed for the US Navy's F-14 Tomcat fighter. This was a 20-bit, multi-chip processor set designed using MOS technology. Classified for many years, its details weren't public until much later, fueling debate about its priority over the 4004.
  • Gilbert Hyatt (Claim): Patented a microprocessor design in 1990 based on work from 1969. However, his design was never manufactured at the time, and his patent claims were largely overturned in later legal battles with Texas Instruments.
  • Texas Instruments TMX 1795 (1970-1971): A one-chip CPU prototype developed for Datapoint Corporation, but never went into production for them.
  • Texas Instruments TMS 1802NC (1971): Marketed as a "calculator-on-a-chip" and programmable during manufacturing, this integrated CPU, ROM, and RAM and is often cited as the first microcontroller.
  • Pico/General Instrument (1971): Developed a single-chip calculator IC with ROM, RAM, and a RISC-like instruction set for Monroe/Litton. Also a strong contender for an early single-chip processor, highlighting the close relationship between early microprocessors and calculator development.

• The First Commercially Available Single-Chip Microprocessor:

  • Intel 4004 (1971): Designed by Federico Faggin (who adapted his silicon-gate technology for the design), Marcian Hoff (architecture proposal), Stanley Mazor (software influence), and Masatoshi Shima (Busicom engineer who specified requirements). The 4004 was a 4-bit processor developed for Busicom calculators. Its release marked the beginning of the era of single-chip microprocessors and is widely credited as the first general-purpose one available commercially.

    Silicon-gate technology (SGT) is a specific MOS fabrication process developed by Federico Faggin that was crucial for building fast, reliable, and dense integrated circuits like the Intel 4004. It allowed for self-aligned gates, reducing parasitic capacitance and enabling higher performance.

Progression of Microprocessor Designs (Bit Size & Features)

Microprocessor design quickly evolved, primarily increasing the "word size" (the number of bits the processor can handle at once) and integrating more features onto the chip.

• 4-bit Processors: Represented by the Intel 4004. Suitable for simple control tasks and early calculators.

• 8-bit Processors:

  • Intel 8008 (1972): Intel's first 8-bit processor, initially designed for Computer Terminals Corporation (Datapoint 2200). It had an 8-bit data bus and a 14-bit address bus (allowing 16 KB of memory).
  • Intel 8080 (1974): An improved, faster, and easier-to-use version of the 8008. A key processor in early hobbyist computers like the Altair 8800 and the Mark-8 kit.
  • Motorola 6800 (1974): A major competitor to the 8080.
  • MOS Technology 6502 (1975): Designed by many of the same people as the 6800 but simpler and much cheaper. It became incredibly popular in the late 1970s and 1980s, powering machines like the Apple II, Commodore 64, and Atari 8-bit computers.
  • Zilog Z80 (1976): An enhanced, binary-compatible version of the Intel 8080, designed by Federico Faggin and Masatoshi Shima after they left Intel. It became even more popular than the 8080, powering home computers like the Sinclair ZX Spectrum, Tandy TRS-80, and MSX machines, as well as arcade games and embedded systems.
  • RCA 1802 (1976): Notable for being one of the first CMOS designs (meaning low power consumption) and available in a radiation-hardened version (Silicon-on-Sapphire or SOS), making it suitable for space applications like the Galileo probe. Its static design allowed the clock to be stopped to save power.
  • Western Design Center (WDC) 65C02 (1982): A CMOS version of the 6502, used in the Apple IIe/IIc and many embedded systems, including medical devices. WDC pioneered processor IP licensing.

  The affordability and simplicity of 8-bit processors were key drivers of the personal computer revolution in the late 1970s and early 1980s. For "building from scratch," these chips represent a golden age where the entire system architecture felt more accessible.

• 12-bit Processors: Less common than 8-bit or 16-bit, but some existed:

  • Intersil 6100 (1975): A 12-bit CMOS processor that executed the instruction set of the DEC PDP-8 minicomputer. Used in some military systems due to its CMOS low-power nature.

• 16-bit Processors: Increased word size allowed for more complex operations and larger memory addressing.

  • National Semiconductor IMP-16 (1973): An early multi-chip 16-bit design.
  • Intel 8086 (1978): Upped Intel's offering to 16 bits, designed for compatibility with the 8080 assembly code (though not binary compatible). It featured a 16-bit data bus and 20-bit address bus (allowing 1 MB memory).
  • Intel 8088 (1979): A version of the 8086 but with an 8-bit external data bus. This chip was chosen for the original IBM PC (1981), cementing the dominance of the x86 architecture in personal computing.
  • Texas Instruments TMS 9900 (1976): A single-chip 16-bit processor compatible with TI's minicomputer line, used in the TI-99/4A home computer.
  • WDC 65816 (1984): A 16-bit upgrade to the 65C02, used in the Apple IIGS and the Super Nintendo Entertainment System (SNES), making it one of the most successful 16-bit designs by volume.
  • Math Coprocessors (x87 series for Intel x86): Early microprocessors often lacked integrated floating-point arithmetic hardware. Separate chips called math coprocessors (like the Intel 8087, 80287, 80387) were developed to perform these calculations much faster than software routines. These effectively acted as extensions to the CPU, creating a multi-chip microprocessor system.

    A Floating-Point Unit (FPU) is a part of a computer system specially designed to carry out operations on floating-point numbers (numbers with fractional parts). Early microprocessors often required a separate chip (a math coprocessor) or software to perform these operations.

• 32-bit Processors: Increased address space and processing power dramatically.

  • Motorola MC68000 (1979): While having a 16-bit external data bus and 24-bit address bus, it had 32-bit registers and an internal 32-bit architecture. It was very influential, powering systems like the Apple Macintosh, Atari ST, and Amiga. Motorola often referred to it as a 16-bit processor externally due to its bus width.
  • AT&T BELLMAC-32A (1982): The first commercially available single-chip fully 32-bit microprocessor (with 32-bit internal paths, buses, and addresses). Used in AT&T's Unix systems.
  • Intel 80386 (1985): Intel's first fully 32-bit x86 processor. It introduced crucial features like a flat 32-bit memory model and paged memory management, which were foundational for modern operating systems.

    Memory Management Unit (MMU): A hardware component (often integrated into the CPU) that handles the mapping of virtual memory addresses used by programs to physical memory addresses. It enables features like virtual memory and memory protection. Memory Segmentation: A memory management technique (used by early x86) where memory is divided into variable-size segments. Paged Memory: A memory management technique (introduced to x86 by the 386) where memory is divided into fixed-size blocks (pages), allowing non-contiguous physical memory to appear contiguous to a program (flat memory model).

  • Motorola 680x0 series (68020, 68030, 68040): The full 32-bit evolution of the 68000, adding full 32-bit buses, MMU integration (68030), and FPU integration (68040). Popular in Unix workstations and embedded systems.
  • ARM Architecture (1985 onwards): Originally Acorn RISC Machine (ARM). Started as a 32-bit RISC design focused on power efficiency. Its flexible licensing model led to its dominance in embedded systems and later mobile devices (smartphones, tablets). Most major semiconductor companies license ARM cores rather than designing their own from scratch.

• 64-bit Processors: Increased word size further, critically expanding the addressable memory space far beyond the 4GB limit of 32-bit systems.

  • Early 64-bit (Non-PC): Designs existed earlier in workstations/servers (like MIPS R4000 in 1991, DEC Alpha in 1992, SPARC) and even gaming consoles (Nintendo 64 in 1996).
  • 64-bit in PCs: The major shift came in the early 2000s.
    • AMD64 (x86-64) (2003): AMD's 64-bit extension to the x86 architecture, backward-compatible with 32-bit x86 software.
    • Intel 64 (EM64T/IA-32e) (2004): Intel's largely compatible implementation of 64-bit x86 extensions. These developments allowed PCs to use more than 4GB of RAM and enabled the development of 64-bit operating systems and applications, leading to significant performance increases for many tasks.
  • ARM 64-bit (AArch64/ARMv8-A) (2011 onwards): Brought 64-bit capability to the ARM architecture, rapidly adopted in mobile devices and increasingly in servers and even desktops.

RISC vs. CISC

Alongside the increase in bit size, a major architectural shift occurred with the rise of Reduced Instruction Set Computer (RISC) designs.

RISC (Reduced Instruction Set Computer): A microprocessor design philosophy that favors a smaller, highly optimized set of simple instructions, each typically taking one clock cycle to execute. Complex operations are performed by sequences of these simple instructions. This often leads to faster clock speeds and more efficient instruction pipelines.

CISC (Complex Instruction Set Computer): A microprocessor design philosophy that favors a larger, rich set of instructions, some of which can perform complex operations (like string manipulation or complex memory addressing) that might take many clock cycles. Early microprocessors like the Intel x86 and Motorola 68k families are often considered CISC.

RISC designs gained prominence in the 1980s and 90s (MIPS, SPARC, PA-RISC, Alpha, ARM). Initially used in high-performance workstations, ARM's focus on power efficiency made RISC dominant in embedded and mobile markets. While x86 is fundamentally CISC, modern x86 processors translate complex instructions into simpler internal micro-operations, exhibiting some RISC-like characteristics internally to benefit from techniques like pipelining and out-of-order execution.

Beyond a Single Core: Multiprocessing

As increasing clock speeds became physically challenging due to heat and power consumption, designers looked to parallelism.

Symmetric Multiprocessing (SMP): A computer architecture where two or more identical processors (or CPU cores) share a single operating system instance and common memory. The operating system schedules processes across the available processors.

Multi-core Processor: A single integrated circuit (chip) that contains two or more independent processing units, called "cores." Each core is essentially a full CPU with its own ALU, control logic, and registers, though they may share resources like cache memory.

SMP systems using multiple separate CPU chips existed earlier (e.g., servers with multiple Intel Pentium Pro chips). The advent of multi-core chips integrated multiple processors onto a single piece of silicon (e.g., IBM POWER4, Intel Core series, AMD Athlon X2). This became the standard approach for improving performance in the 2000s.

For parallel tasks (software designed to run multiple parts simultaneously), multi-core processors offer significant performance gains, following principles related to Amdahl's Law, which describes the theoretical speedup achievable from parallelism.

Applications of Microprocessors

Microprocessors are far more ubiquitous than most people realize. While personal computers and servers use powerful general-purpose microprocessors, the vast majority produced annually are embedded in other devices.

Embedded System: A computer system (often with a microprocessor or microcontroller) designed for specific control functions within a larger mechanical or electronic system, often with real-time computing constraints. They are not general-purpose computers.

Examples of microprocessor applications:

• Personal Computers & Servers: High-performance general-purpose processors (Intel Core/Xeon, AMD Ryzen/Epyc, Apple M-series).
• Mobile Devices: System-on-a-Chip (SoC) designs integrating ARM processors, graphics, memory controllers, radio modems, etc. (smartphones, tablets).
• Vehicles: Engine management, braking systems (ABS), infotainment, navigation, comfort controls.
• Household Appliances: Microwaves, washing machines, refrigerators, thermostats.
• Industrial Control: Automation systems, robotics, test equipment.
• Consumer Electronics: TVs, DVD/Blu-ray players, digital cameras, gaming consoles (often use specialized processors like GPUs or SoCs).
• Peripherals: Printers, scanners, keyboards, hard drives often contain microcontrollers or microprocessors.
• Toys: Even many modern toys contain simple processors.

The flexibility of programmable microprocessor control allows manufacturers to add features, improve performance, and update products through software changes, often with minimal hardware redesign.

Market Overview

Historically, 8-bit microcontrollers dominated the market by volume due to their widespread use in simple embedded systems. While 32-bit and 64-bit processors command the highest market value (driven by PC and server sales), the sheer number of processors in everyday embedded devices means smaller processors represent a massive volume market. Billions of CPUs are manufactured annually, with the vast majority going into non-PC embedded applications.

Conclusion

The microprocessor is the technological marvel that enabled the computing revolution. From the early 4-bit chips powering calculators to the multi-core 64-bit powerhouses in our computers and phones, its evolution reflects decades of innovation in semiconductor manufacturing and architectural design. For someone exploring "The Lost Art of Building a Computer from Scratch," understanding the microprocessor provides insight into the fundamental component that orchestrates computation, revealing the intricate dance between hardware and software that brings a machine to life. While modern microprocessors are incredibly complex, their core principles – fetching, decoding, and executing instructions using an ALU, control logic, and registers – remain consistent with their pioneering ancestors.

---