Computer Architecture

Part: Computer Science · Chapter: Computer Architecture · Edition: 2026-07-12
Keywords: ISA, pipeline, memory hierarchy, concurrency, accelerators
Glossary: ISA, pipeline, cache, von Neumann — see GLOSSARY

At a glance

• Computer architecture is the organization of processors, memory, interconnects and programmable fabrics.
• The chapter indexes instruction sets, pipelines, caches and related design choices.
• It is an orientation to the field, not a design manual and not a purchasing guide.

Online references (live)

• Computer architecture
• Instruction set architecture
• Cache (computing)

Offline snapshots (link-rot shield)

Offline snapshot omitted in this web edition. Offline snapshot · Computer architecture · https://en.wikipedia.org/wiki/Computer_architecture · retrieved 2026-07-12

Computer architecture

Offline snapshot omitted in this web edition. Offline snapshot · Instruction set architecture · https://en.wikipedia.org/wiki/Instruction_set_architecture · retrieved 2026-07-12

Instruction set architecture

Offline snapshot omitted in this web edition. Offline snapshot · Cache (computing) · https://en.wikipedia.org/wiki/Cache_(computing) · retrieved 2026-07-12

Cache (computing)

This chapter maps how computers are organized: instruction sets, processors, memory hierarchies, interconnects and the programmable fabrics that implement them. It is an index of the field, not a design manual and not a purchasing guide.

Applications at Keyne Digital Assets

Architecture is the constraint underneath any system that stores and transforms knowledge. We use this chapter when we reason about performance, isolation and the hardware path that carries Situation Monitor and our services. We do not manufacture processors, and this page is not a hardware catalogue.

Roadmap

1. Introduction to Computer Architecture
   * Definition of Computer Architecture
   * Historical Development of Computer Architecture
   * Key Concepts and Terminology
   * Instruction Set Architecture (ISA)
2. Data Representation and Arithmetic
   * Binary, Decimal, and Hexadecimal Number Systems
   * Integer and Floating-Point Representation
   * Two’s Complement Representation
   * Arithmetic Operations (Addition, Subtraction, Multiplication, Division)
3. Central Processing Unit (CPU)
   * CPU Components and Organization
   * Register File and Data Path
   * Control Unit and Instruction Execution Cycle
   * Microarchitecture vs. Instruction Set Architecture
4. Memory Hierarchy
   * Memory Technologies: RAM, ROM, Cache, Virtual Memory
   * Memory Hierarchy Levels: Registers, Cache, Main Memory, Disk Storage
   * Memory Organization and Addressing
5. Instruction Set Architecture (ISA)
   * Types of ISA: CISC vs. RISC
   * Instruction Formats
   * Addressing Modes
   * Data Transfer, Arithmetic, and Logic Instructions
6. Pipelining and Superscalar Architecture
   * Pipelining Concepts and Hazards
   * Superscalar Execution and Multiple Issue Processors
   * Branch Prediction and Speculative Execution
7. Caches and Memory Systems
   * Cache Organization: Direct-Mapped, Set-Associative, Fully Associative
   * Cache Coherency and Cache Replacement Policies
   * Memory Management: Virtual Memory and Page Tables
8. Input/Output (I/O) Systems
   * I/O Devices and Interfaces
   * Interrupts and DMA (Direct Memory Access)
   * I/O Controllers and I/O Addressing
9. Parallel Architectures
   * Flynn’s Taxonomy: SISD, SIMD, MISD, MIMD
   * Multiprocessors and Multicore Processors
   * Thread-Level Parallelism and SMT (Simultaneous Multithreading)
10. Performance Evaluation and Benchmarking

• Metrics for Performance Evaluation: CPI, MIPS, MFLOPS, etc.
• Amdahl’s Law and Gustafson’s Law
• Benchmark Suites and Performance Analysis Tools

11. Energy-Efficient and Green Computing

• Power Consumption in Processors and Systems
• Power Management Techniques
• Environmental Impact and Sustainable Computing

12. Future Trends in Computer Architecture

• Emerging Technologies: Quantum Computing, Neuromorphic Computing, etc.
• Heterogeneous Computing and Accelerators
• Challenges and Opportunities in Future Architectures

This definitive index for Computer Architecture covers the structural logic and hardware design that enable computation. In 2026, the field is dominated by the move toward Domain-Specific Architectures (DSAs), the rise of RISC-V, and the integration of AI-native hardware.

---

1. Fundamentals and Instruction Set Architecture (ISA)

The abstract interface between hardware and software.

• ISA Classifications:
• RISC (Reduced Instruction Set Computer) vs. CISC (Complex Instruction Set Computer).
• Load/Store Architectures vs. Register-Memory Architectures.
• Modern ISA Families: x86-64, ARMv9, and the open-source RISC-V ecosystem.
• Addressing Modes: Immediate, Direct, Indirect, Indexed, and PC-relative.
• Data Representation: Fixed-point, Floating-point (IEEE 754), and Bfloat16 (optimized for AI).
• Endianness: Big-endian vs. Little-endian memory mapping.

---

2. Microarchitecture and Processor Design

The internal implementation of an ISA.

• Pipelining:
• The Classic 5-stage Pipeline (Fetch, Decode, Execute, Memory, Write-back).
• Pipeline Hazards: Data hazards (stalls/forwarding), Structural hazards, and Control hazards.
• Instruction-Level Parallelism (ILP):
• Superscalar Execution: Multiple instructions per clock cycle.
• Out-of-Order (OoO) Execution: Tomasulo’s Algorithm and Reorder Buffers (ROB).
• Speculative Execution: Branch Prediction (Static vs. Dynamic), Tournament Predictors.
• VLIW (Very Long Instruction Word): Static scheduling by compilers.

---

3. The Memory Hierarchy

Managing the “Memory Wall” (the speed gap between CPU and RAM).

• Cache Architecture:
• Cache Levels: L1 (Instruction/Data), L2, and L3 (Last-Level Cache).
• Mapping Techniques: Direct-mapped, Fully Associative, and Set-Associative.
• Replacement Policies: LRU (Least Recently Used), LFU, and Pseudo-LRU.
• Virtual Memory:
• Paging and Segmentation.
• TLB (Translation Lookaside Buffer): Caching address translations.
• Page Table structures (Hierarchical, Inverted).
• Main Memory (DRAM): DDR5/DDR6, HBM (High Bandwidth Memory), and PIM (Processing-in-Memory).
• Cache Coherence: Snooping protocols vs. Directory-based protocols (MESI/MOESI).

---

4. Parallelism and Multicore Systems

Scaling performance through multiple processing units.

• Flynn’s Taxonomy: SISD, SIMD (Vector processing), MISD, and MIMD.
• Multicore Architectures:
• Homogeneous vs. Heterogeneous (e.g., Apple M-series P-cores and E-cores).
• SMT (Simultaneous Multithreading) / Hyper-threading.
• Interconnect Topologies: Bus, Ring, Mesh, Crossbar, and Network-on-Chip (NoC).
• Memory Consistency Models: Sequential Consistency vs. TSO (Total Store Ordering) vs. Weak Consistency.

---

5. Domain-Specific Accelerators (DSA)

The transition from general-purpose CPUs to specialized silicon.

• GPU Architecture: Many-core SIMT (Single Instruction, Multiple Threads) processing.
• AI & Machine Learning Accelerators:
• TPU (Tensor Processing Units): Systolic array architectures.
• NPUs (Neural Processing Units): Optimized for matrix-vector multiplication.
• FPGA (Field Programmable Gate Arrays): Reconfigurable hardware logic.
• ASIC (Application-Specific Integrated Circuit): Custom-built silicon for extreme efficiency.

---

6. Storage Systems and I/O

• Bus Systems: PCIe 6.0/7.0, CXL (Compute Express Link) for cache-coherent interconnects.
• Direct Memory Access (DMA): Offloading data transfers from the CPU.
• Non-Volatile Memory (NVM): SSDs, NVMe protocols, and emerging technologies like MRAM.
• RAID Levels: 0, 1, 5, 6, 10 for reliability and performance.

---

7. Energy-Efficient and Reliable Design

• Power Management: DVFS (Dynamic Voltage and Frequency Scaling), Power Gating, and Dark Silicon.
• Reliability: ECC (Error Correction Code) memory, Checkpointing, and TMR (Triple Modular Redundancy).
• Thermal Management: Throttle mechanisms and advanced cooling integration.

---

8. Advanced Frontiers (2026)

• Chiplets and 3D Packaging: Breaking monolithic dies into smaller chips interconnected via high-speed substrates.
• Confidential Computing: Hardware-level TEEs (Trusted Execution Environments) like Intel SGX or ARM TrustZone.
• Neuromorphic Computing: Spiking Neural Networks implemented in hardware.
• Quantum-Classical Hybrid Architecture: Designing “Quantum Control Units” to bridge classical CPUs and Qubits.
• Approximate Computing: Trading off accuracy for massive gains in energy efficiency.

---

Comparison of Execution Paradigms

Introduction

Introduction to Computer Architecture

Computer architecture is a fundamental field of computer science and engineering that deals with the design and organization of computer systems. It encompasses the structure, behavior, and functionality of a computer at various levels, from the individual electronic components to the overall system organization. Computer architecture plays a crucial role in determining the performance, power efficiency, and capabilities of computing devices, ranging from tiny embedded systems to large-scale supercomputers.

Definition of Computer Architecture:

Computer architecture refers to the conceptual and structural design of a computer system, including its internal components, memory hierarchy, instruction set, and data paths. It defines the interfaces between hardware and software, specifying how the CPU interprets and executes instructions and how it communicates with memory, input/output devices, and other components. In essence, computer architecture establishes the blueprint for constructing efficient, reliable, and scalable computer systems.

Historical Development of Computer Architecture:

The development of computer architecture can be traced back to the origins of computing itself. Early computers were based on mechanical or electromechanical components, and their architecture was relatively simple. However, with the advent of electronic components and the transistor, computer architecture evolved significantly. Here are some key milestones in the historical development of computer architecture:

1. First-Generation Computers (1940s-1950s): The first-generation computers, such as the ENIAC and UNIVAC, used vacuum tubes for computation. These machines were large, power-hungry, and had limited processing capabilities.
2. Second-Generation Computers (1950s-1960s): The second-generation computers replaced vacuum tubes with transistors, making them more reliable and energy-efficient. They were still large and expensive, primarily used in scientific and military applications.
3. Third-Generation Computers (1960s-1970s): The third-generation computers introduced integrated circuits (ICs), which significantly increased computing power and reduced the size of computers. These computers were more commercially available and found applications in business and research.
4. Fourth-Generation Computers (1970s-1980s): The fourth-generation computers saw the widespread adoption of microprocessors, where multiple components of the CPU were integrated into a single chip. This revolutionized the computing industry, leading to smaller, more affordable, and more powerful computers.
5. Fifth-Generation Computers (1980s-present): The fifth-generation of computers has witnessed continuous advancements in microprocessor technology, including higher clock speeds, multi-core designs, and improved parallel processing capabilities. It also saw the rise of personal computers and mobile devices.

Key Concepts and Terminology:

When discussing computer architecture, several key concepts and terminologies are important to understand:

• Instruction Set: The set of instructions that a CPU can execute, defining the operations it can perform. Instructions include arithmetic, logic, control transfer, and data movement operations.
• Data Path: The part of the CPU responsible for performing arithmetic and logic operations. It includes ALU (Arithmetic Logic Unit), registers, and data buses.
• Control Unit: The component responsible for fetching and decoding instructions and coordinating the execution of instructions in the CPU.
• Memory Hierarchy: The organization of memory in a computer system, ranging from high-speed, small-capacity registers and caches to slower, larger main memory and external storage.
• Pipelining: A technique to improve CPU performance by breaking down instruction execution into overlapping stages, allowing multiple instructions to be processed simultaneously.
• Parallelism: Exploiting multiple processing units to execute tasks concurrently, including instruction-level parallelism (ILP) and thread-level parallelism (TLP).

Instruction Set Architecture (ISA):

The Instruction Set Architecture (ISA) is a crucial aspect of computer architecture as it defines the machine language that a CPU can understand and execute. The ISA specifies the set of instructions that the CPU supports, their formats, addressing modes, and the behavior of each instruction. The ISA serves as an interface between hardware and software, allowing software developers to write programs independent of the underlying hardware implementation.

There are two main types of ISAs:

1. Complex Instruction Set Computing (CISC): CISC ISAs include a wide variety of instructions that can perform complex operations. Each CISC instruction can execute multiple low-level operations, but they might take multiple clock cycles to complete. Intel’s x86 architecture is an example of a CISC ISA.
2. Reduced Instruction Set Computing (RISC): RISC ISAs have a smaller, simpler set of instructions, each performing a single low-level operation. RISC architectures prioritize simpler and faster instructions that can execute in a single clock cycle. ARM is an example of a popular RISC ISA.

The choice between CISC and RISC design philosophies impacts the performance, complexity, and power efficiency of the CPU. Many modern CPUs, including ARM and x86 processors, incorporate elements of both CISC and RISC architectures, striking a balance between instruction complexity and execution speed.

Computer architecture is a fundamental concept in computer science and engineering that refers to the structure, design, and organization of a computer system. It defines how the different components of a computer, such as the central processing unit (CPU), memory, input/output (I/O) devices, and storage, are interconnected and work together to execute instructions and perform tasks. Computer architecture plays a crucial role in determining the overall performance, efficiency, and capabilities of a computer system. The key aspects of computer architecture include the following:

1. Von Neumann Architecture: The most widely used computer architecture is the Von Neumann architecture, named after the Hungarian-American mathematician and computer scientist John von Neumann. This architecture is characterized by the separation of memory and processing units, each with its own distinct components. It consists of the following key components:

• Central Processing Unit (CPU): The CPU is the “brain” of the computer, responsible for executing instructions and performing calculations. It includes the Arithmetic Logic Unit (ALU) for mathematical operations and the Control Unit (CU) for instruction decoding and control.
• Memory: Memory is used to store data and instructions needed for the CPU’s operations. In the Von Neumann architecture, both data and instructions are stored in a single memory system, known as the Random Access Memory (RAM).
• Input/Output (I/O) Devices: I/O devices enable communication between the computer and external peripherals, such as keyboards, mice, displays, printers, and storage devices.

2. Instruction Set Architecture (ISA): The Instruction Set Architecture is a crucial aspect of computer architecture. It defines the set of instructions that a CPU can execute and how these instructions are encoded. The ISA serves as an interface between software and hardware, allowing software programs to be executed on different hardware platforms with compatible ISAs.

3. Parallelism and Pipelining: Computer architecture often involves techniques to improve performance through parallelism and pipelining. Parallelism allows multiple instructions or tasks to be executed simultaneously, exploiting the capabilities of multiple cores or processors. Pipelining breaks down the instruction execution into several stages, allowing different stages of different instructions to overlap, thereby improving efficiency.

4. Memory Hierarchy: Computer architecture incorporates a memory hierarchy, consisting of different levels of memory with varying speeds and capacities. The memory hierarchy includes caches (small and fast memory close to the CPU), main memory (larger and slower memory), and secondary storage (such as hard drives and solid-state drives).

5. RISC and CISC Architectures: Computer architectures are often classified into Reduced Instruction Set Computing (RISC) and Complex Instruction Set Computing (CISC). RISC architectures have a small set of simple and uniform instructions, focusing on efficiency and pipelining. CISC architectures have a larger and more complex set of instructions, aiming to reduce the number of instructions required to perform a task.

6. Advanced Architectures: Modern computer architecture has seen the development of advanced architectures, such as multicore processors, vector processors, and specialized accelerators like Graphics Processing Units (GPUs) and Tensor Processing Units (TPUs). These architectures are designed to handle specific tasks efficiently, such as graphics rendering, machine learning, and artificial intelligence.

In conclusion, computer architecture is the foundation of how computers are designed and organized, determining their performance, capabilities, and compatibility. Advances in computer architecture have been critical in the evolution of computing technology, leading to increasingly powerful and versatile computer systems that have transformed the way we live, work, and interact with the digital world.

Digital logic and binary numbers

The use of binary numbers as a standard in computer architecture can be traced back to the works of Gottfried Wilhelm Leibniz and later influenced by Alan Turing. Their contributions, and the significance of binary numbers in computer architecture, are outlined below:

1. Leibniz and Binary Numbers: Gottfried Wilhelm Leibniz, a German mathematician, philosopher, and polymath, is credited with introducing binary numbers to the world. In 1703, he published an essay titled “Explanation of the Binary Arithmetic” in which he proposed a binary numeral system based on the number 2. In this system, he used only two symbols (usually represented as 0 and 1) to represent numbers. Leibniz was inspired by the Chinese I Ching (Book of Changes), which also used a binary-like notation.

Leibniz recognized that numbers could be represented using a positional system with only two digits (0 and 1) instead of the traditional decimal system (base-10) with ten digits (0 to 9). He saw the binary system’s elegance and efficiency, as it could easily represent any number with simple on-off (0 or 1) states.

2. Turing Machines and Binary Computations: Alan Turing, a British mathematician and computer scientist, made significant contributions to the development of theoretical computer science and computing machines. He is famous for conceiving the concept of a Turing machine in 1936, a theoretical device that could manipulate symbols on an infinite tape according to a set of rules.

Turing machines work with symbols, and in his seminal paper “On Computable Numbers, with an Application to the Entscheidungsproblem,” Turing demonstrated that a Turing machine could simulate any computation that could be done by a human following a specific algorithm. The Turing machine, being a theoretical construct, works with discrete symbols, which aligns perfectly with the binary representation.

Turing’s theoretical work provided a foundation for understanding computation and what we now call the Von Neumann architecture, which forms the basis of modern computers. The Von Neumann architecture employs binary digits (bits) to represent and manipulate data, and it uses binary arithmetic in its instruction set to perform operations.

3. Binary and Electronic Computers: When electronic computers were developed in the mid-20th century, the use of binary digits (bits) became a practical choice for representing data and computations. Electronic components, such as vacuum tubes and later transistors, could easily represent binary states (on-off) in electronic circuits.

Binary representation simplified electronic circuitry, as it required only two voltage levels to represent information, making it easier to build and manage digital circuits. The binary system also provided a clear distinction between “true” and “false” states, which made it ideal for logical operations.

In summary, the use of binary numbers in computer architecture can be traced back to Leibniz’s insights into the simplicity and elegance of a base-2 numeral system. Later, Alan Turing’s theoretical work with Turing machines demonstrated the capability of binary-based computations, and this concept was instrumental in the design of electronic computers that use binary digits (bits) to represent and process data, forming the foundation of modern computer architecture.

Pioneers

The development of calculators and computers involved the efforts of several pioneers and inventors over the centuries. Besides Leibniz and Turing, numerous other individuals played essential roles in the early stages of calculator and computer history. Some notable figures include:

1. Blaise Pascal (1623-1662): Blaise Pascal, a French mathematician, physicist, and inventor, designed and built the mechanical calculator known as the “Pascaline” in 1642. It was one of the earliest mechanical devices capable of performing addition and subtraction.
2. Charles Babbage (1791-1871): Often referred to as the “father of the computer,” Charles Babbage, an English mathematician and engineer, conceptualized and designed the “Analytical Engine” in the early 19th century. Though never completed during his lifetime, the Analytical Engine was a remarkable step toward modern programmable computers, with its ability to store programs and perform complex calculations.
3. Ada Lovelace (1815-1852): Ada Lovelace, an English mathematician and writer, is known for her work on Charles Babbage’s Analytical Engine. She is often credited with writing the first computer program, recognizing that the machine could be used for more than just number-crunching.
4. Konrad Zuse (1910-1995): Konrad Zuse, a German engineer, built the “Z1” in the 1930s, considered one of the first programmable digital computers. He continued to refine his designs and developed several other Z-series machines.
5. Howard Aiken (1900-1973): Howard Aiken, an American physicist and computer scientist, led the team that built the “Harvard Mark I” computer in the 1940s. It was a large electro-mechanical calculator capable of performing complex calculations.
6. John von Neumann (1903-1957): John von Neumann, a Hungarian-American mathematician and computer scientist, made significant contributions to the architecture and design of modern computers. His work on the “von Neumann architecture” became the basis for many early computers, emphasizing the stored-program concept.
7. Tommy Flowers (1905-1998): Tommy Flowers, a British engineer, designed and built “Colossus,” the world’s first programmable electronic computer. It was used to break encrypted German codes during World War II.
8. Grace Hopper (1906-1992): Grace Hopper, an American computer scientist, was a pioneer in computer programming languages and worked on the development of early computers like the Harvard Mark I and the UNIVAC I.
9. John W. Mauchly and J. Presper Eckert: This duo co-designed the “ENIAC” (Electronic Numerical Integrator and Computer), one of the first general-purpose electronic digital computers, completed in 1945.

These are just a few of the many individuals who made significant contributions to the early development of calculators and computers. Their innovative ideas and inventions paved the way for the incredible progress that led to modern computing technology.

8-bit architecture

An 8-bit computer is a type of computer architecture where the central processing unit (CPU) operates on 8-bit data at a time. It was common in early personal computers and microcontrollers. Below are the main components of an 8-bit computer:

1. Central Processing Unit (CPU): The CPU is the brain of the computer and responsible for executing instructions. In an 8-bit computer, the CPU is designed to handle 8-bit data and typically consists of an Arithmetic Logic Unit (ALU) for performing arithmetic and logical operations, control unit for managing instruction execution, and registers to store temporary data.
2. Memory: An 8-bit computer typically has two main types of memory: Random Access Memory (RAM) and Read-Only Memory (ROM). RAM is used for temporary storage of data and programs during execution, while ROM contains the firmware or permanent instructions used to bootstrap the system and store essential programs like the Basic Input/Output System (BIOS).
3. Data Bus: The data bus is a set of electrical lines that allow data to be transferred between the CPU and memory, as well as other peripherals. In an 8-bit computer, the data bus is 8 bits wide, meaning it can transfer 8 bits of data in parallel.
4. Address Bus: The address bus consists of electrical lines used to specify memory locations or addresses. In an 8-bit computer, the address bus is typically 16-bits wide, allowing the CPU to address up to 64KB of memory (2^16 = 65,536).
5. Control Unit: The control unit manages the flow of data and instructions within the CPU and coordinates activities between the CPU and other components. It fetches instructions from memory, decodes them, and executes them accordingly.
6. Input/Output (I/O) Ports: These are the interfaces that allow the computer to communicate with external devices such as keyboards, monitors, printers, and storage devices. I/O ports are essential for inputting data into the computer and displaying or storing the results of computations.
7. Clock: The clock is a timing device that synchronizes the operations of the computer’s components. It generates a regular pulse, and the CPU executes one instruction per clock cycle. The clock speed determines the number of instructions the CPU can execute per second.
8. ALU (Arithmetic Logic Unit): The ALU is a critical component of the CPU responsible for performing arithmetic operations (e.g., addition, subtraction) and logical operations (e.g., AND, OR) on data. In an 8-bit computer, the ALU operates on 8-bit binary numbers.
9. Accumulator: The accumulator is a special register in the CPU that stores intermediate results of computations performed by the ALU. It is often used for temporary storage during arithmetic operations.
10. Instruction Set: The instruction set is a collection of machine-level instructions that the CPU can execute. In an 8-bit computer, instructions are typically 8 bits long, and the instruction set determines the operations the CPU can perform.

These components work together to enable the basic functionalities of an 8-bit computer, including data processing, storage, and interaction with external devices. Although 8-bit computers are limited compared to modern architectures, they were instrumental in the early days of computing and helped pave the way for more advanced systems.

CPU

Modern CPU architectures consist of several key components beyond the ALU and accumulators. These components work together to execute instructions, process data, and manage the flow of information within the CPU. Some of the other essential components found in modern CPU architectures include:

1. Control Unit (CU): The control unit manages the execution of instructions, fetching them from memory, decoding them, and coordinating the operations of other CPU components. It generates control signals to direct data flow and control the timing of operations.
2. Registers: CPU registers are small, fast storage locations used to hold data, instructions, and addresses temporarily during execution. Apart from the accumulator, there are other specialized registers, such as the program counter (PC), instruction register (IR), memory data register (MDR), memory address register (MAR), and others.
3. Floating-Point Unit (FPU): The FPU is a specialized component responsible for performing floating-point arithmetic operations, which are typically used in scientific, engineering, and multimedia applications.
4. Instruction Decoder: This unit decodes instructions fetched from memory, determining the operation to be performed and the operands involved.
5. Cache Memory: In addition to the L2 cache, modern CPUs have multiple levels of cache memory (L1, L2, and sometimes L3) to store frequently accessed data and instructions closer to the CPU, reducing the memory access time.
6. Memory Management Unit (MMU): The MMU handles virtual memory translation, mapping virtual addresses to physical addresses, enabling memory protection, and managing memory access permissions.
7. Bus Interface: The bus interface unit manages data transfer between the CPU and other components, such as main memory, peripheral devices, and the system bus.
8. Clock Generator: The clock generator generates the clock signal that synchronizes the operations of different CPU components, ensuring proper timing and coordination.
9. Branch Prediction Unit: This unit predicts the outcome of conditional branches in program flow, improving execution efficiency by fetching and executing instructions speculatively.
10. Vector Processing Units: In some high-performance CPUs, vector processing units are included to perform SIMD (Single Instruction, Multiple Data) operations, enabling parallel processing on arrays of data.
11. Out-of-Order Execution Unit: In modern CPUs with out-of-order execution capabilities, the execution units can rearrange the order of instructions dynamically to utilize available resources efficiently.

These components work in harmony to perform complex computations, process data, and execute instructions efficiently in modern CPU architectures. The design and integration of these components vary across different CPU manufacturers and models.

Instruction set

An instruction set is a fundamental part of a computer architecture that defines the set of instructions that a central processing unit (CPU) can understand and execute. It serves as the interface between the hardware and the software, allowing a programmer or compiler to communicate with the CPU and control its operations. The instruction set architecture (ISA) is a crucial aspect of a computer’s design as it determines the machine-level programming model and the types of operations that the CPU can perform.

There are two main types of instruction sets:

1. Complex Instruction Set Computers (CISC): CISC architectures have a rich set of complex and specialized instructions that can perform multiple operations in a single instruction. These instructions are generally more powerful and can execute complex tasks directly, reducing the number of instructions needed to complete a task. CISC architectures tend to be more hardware-oriented and provide a high-level abstraction to the programmer.

Advantages of CISC:

• Fewer instructions needed for a task, reducing memory requirements.
• Complex instructions can optimize certain operations, making some tasks faster.
• Legacy support for older instruction sets, ensuring compatibility with older software.

Disadvantages of CISC:

• Complex instructions require more transistors and chip space, leading to larger and more power-hungry CPUs.
• Increased complexity makes it harder to design and manufacture CPUs.
• Difficulty in pipelining and superscalar execution due to varying instruction lengths and formats.

2. Reduced Instruction Set Computers (RISC): RISC architectures, on the other hand, have a simplified and streamlined set of instructions that perform only one operation at a time. These instructions are designed to be executed in a single clock cycle, making the CPU’s execution pipeline more straightforward and efficient. RISC architectures tend to be more software-oriented, relying on compilers to optimize code.

Advantages of RISC:

• Simpler instruction set makes it easier to design, manufacture, and optimize CPUs.
• Easier pipelining and superscalar execution due to uniform instruction lengths and formats.
• Smaller chip size and lower power consumption.

Disadvantages of RISC:

• Some tasks may require more instructions, leading to larger code size and potentially slower execution.
• Simplified instructions may not directly correspond to high-level language constructs, requiring more effort from the compiler.

Modern computer architectures often use a combination of CISC and RISC principles, striking a balance between performance, power efficiency, and ease of design. Some CPUs implement a RISC core with additional specialized instructions to improve performance for specific tasks.

The instruction set is a critical aspect of computer architecture, influencing the overall performance, power efficiency, and compatibility of a CPU. It plays a significant role in determining how software interacts with the hardware, making it a foundational element in the development of computing systems.

Chipset

A chipset in a modern computer architecture refers to a collection of integrated circuits (ICs) that work together to manage and control various functions and communication between the CPU and other components on the motherboard. The chipset plays a crucial role in the overall functioning and performance of a computer system. The chipset’s components, and its relationship with the CPU and other components, are outlined below:

1. Northbridge and Southbridge: In traditional chipsets, you may find two main components: the Northbridge and the Southbridge. However, in modern architectures, especially with the integration of components into the CPU or the use of System-on-Chip (SoC) designs, the traditional distinction may not be as prominent. Nonetheless, the functions of the Northbridge and Southbridge are still relevant.

• Northbridge: Historically, the Northbridge handled high-speed communication between the CPU and memory (RAM) and other components directly connected to the CPU, such as the graphics card through the PCIe interface. It controlled the Front Side Bus (FSB) or Quick Path Interconnect (QPI) between the CPU and Northbridge.
• Southbridge: The Southbridge, on the other hand, managed communication between the CPU and other peripheral devices, including USB ports, SATA ports, audio, network interfaces, and legacy interfaces like PS/2 and PCI slots. It also controlled lower-speed buses like the PCI bus.

2. Integrated Memory Controller (IMC): With the advancement of CPU architectures, many modern processors now include an Integrated Memory Controller (IMC) directly on the CPU die. The IMC enables the CPU to communicate directly with the system memory (RAM) without the need for a separate Northbridge component. This integration reduces latency and improves memory access performance.
3. Integrated Graphics Processing Unit (GPU): Some modern CPUs also include an Integrated Graphics Processing Unit (GPU) on the same die. This eliminates the need for a separate dedicated graphics card for basic display tasks, making the system more power-efficient and suitable for everyday computing needs.
4. System-on-Chip (SoC) Designs: In mobile devices and some modern laptops, the chipset may be integrated into a single System-on-Chip (SoC). SoCs combine the CPU, GPU, memory controller, and other essential components into a single integrated circuit, reducing power consumption, space, and cost.
5. Communication with Peripherals: The chipset facilitates communication between the CPU and various peripheral devices through different interfaces, such as PCIe, USB, SATA, and Ethernet. It provides the necessary data pathways and controllers to ensure seamless data transfer and operation of these peripherals.
6. BIOS and Firmware Management: The chipset also includes firmware to manage the system BIOS (Basic Input/Output System) and provide essential system initialization and configuration services during the boot process.

In summary, the chipset in modern computer architectures is responsible for managing and coordinating communication between the CPU and various components, including memory, peripherals, and graphics devices. While traditional distinctions like the Northbridge and Southbridge may have evolved or merged into the CPU or SoC, the chipset’s role in ensuring the smooth functioning of the entire system remains crucial.

BUS

In addition to being managed by the chipset, there are several important aspects and characteristics of the bus in modern computer architectures:

1. Data Transfer: The bus serves as a communication pathway that allows data and instructions to be transferred between different components of the computer system, including the CPU, memory, peripherals, and other devices.
2. Types of Buses: Modern computers typically have several types of buses, each serving a specific purpose. Some common types include:
   * System Bus: This is the primary bus that connects the CPU to the main memory (RAM). It includes the address bus (for specifying memory locations) and the data bus (for transferring data between the CPU and memory).
   * Front Side Bus (FSB): Historically, the FSB was used to connect the CPU with the Northbridge, but with newer architectures and integrated components, this bus concept has been largely replaced.
   * Peripheral Buses: These buses connect the CPU with peripheral devices such as USB, SATA, PCIe, and others.
3. Bus Width: The bus width refers to the number of data lines a bus uses to transfer data simultaneously. For example, a 64-bit bus transfers 64 bits of data in one operation. Wider buses can transfer more data at a time, improving data throughput.
4. Bus Speed: The bus speed, often measured in MHz or GHz, determines how quickly data can be transferred between components. Higher bus speeds generally result in faster data transfer rates.
5. Bus Arbitration: When multiple devices want to use the bus simultaneously, bus arbitration is employed to resolve conflicts and prioritize access. Different bus architectures use various methods for arbitration.
6. Bottleneck: The bus can become a bottleneck in the system if it cannot keep up with the demands of data transfer between components. This is why faster and wider buses are critical for improving overall system performance.
7. Expansion Slots: The bus also enables the use of expansion slots on the motherboard, where additional cards, such as graphics cards, network cards, and sound cards, can be installed.
8. Plug and Play: Buses often support plug-and-play functionality, allowing devices to be added or removed while the system is running without requiring manual configuration.
9. Bus Protocols: Buses use specific protocols for data transfer, error detection, and other communication functions. Common protocols include PCI, PCIe, USB, SATA, and Ethernet.

In summary, the bus is a critical component in modern computer architectures that enables communication and data transfer between the CPU, memory, and various peripherals. It comes in different types, widths, and speeds, all of which affect the overall performance and capabilities of the computer system. While the chipset plays a role in managing certain aspects of the bus itself is a foundational element for efficient and seamless operation in a computer system.

ALU

The ALU (Arithmetic Logic Unit) is a fundamental component of a CPU responsible for performing arithmetic and logical operations on data. It does not have any specific alternative names as “ALU” itself is the standard term used across computer architecture and design.

However, depending on the context and the specific architecture, different terms might be used to refer to the ALU or its various components:

1. Arithmetic Unit: Sometimes, the ALU is referred to as the “arithmetic unit” since its primary function is to perform arithmetic operations such as addition, subtraction, multiplication, and division.
2. Logic Unit: As the ALU also handles logical operations like AND, OR, XOR, and NOT, it may be referred to as the “logic unit.”
3. Execution Unit: In some CPUs, the ALU is a part of a larger “execution unit” responsible for executing instructions, which includes other components like control units and registers.
4. Data Path: The ALU, along with associated multiplexers and data manipulation components, can be considered a critical part of the “data path” within a CPU.
5. Core ALU: In multi-core processors, each core typically has its own ALU, and the term “core ALU” might be used to refer to the specific ALU within a core.
6. Integer Unit: In CPUs that have separate units for handling different data types (e.g., integer and floating-point), the ALU is part of the “integer unit.”

It’s important to note that the ALU is a well-defined and standard component of a CPU, and its function remains consistent across various computer architectures. The term “ALU” is widely used and understood by computer engineers, architects, and software developers.

Accumulators

On modern computers, the accumulator is often referred to by different names depending on the architecture and context. Some of the common alternative names for the accumulator include:

1. Accumulator Register: This is the full name of the accumulator, and it emphasizes that it is a specific type of register used for accumulation operations.
2. A-Register: In some older architectures or assembly languages, the accumulator is simply referred to as the “A” register.
3. ACC: An abbreviation for “accumulator.”
4. ALU (Arithmetic Logic Unit): In some architectures, the term “accumulator” is used interchangeably with the ALU since the accumulator is an essential component of the ALU responsible for storing intermediate results of arithmetic and logical operations.
5. Accumulating Register: This name emphasizes the register’s role in accumulating intermediate results.
6. Working Register: In some contexts, the accumulator is also called the “working register” because it often holds intermediate data during processing.
7. Scratchpad Register: This term is used when the accumulator is used as a temporary storage location during the execution of instructions.

It’s important to note that the term “accumulator” is more common in older computer architectures and assembly languages. In modern CPUs and high-level programming languages, the specific register names may not always be explicitly mentioned or exposed to programmers, but the concept of an accumulator or similar functionality is still present within the processor’s architecture.

Memory

SR Latch, D Latch, and D Flip-Flop are fundamental digital electronic circuits used in digital systems for storing and manipulating binary data. They are essential building blocks for memory elements and sequential logic circuits. Each of these components is outlined below:

1. SR Latch (Set-Reset Latch): An SR latch is a basic bistable circuit that can store one bit of data. It has two inputs: Set (S) and Reset (R). The latch can be in one of two stable states: SET (Q = 1) or RESET (Q = 0). The state transitions occur based on the input values. Here’s how it works:

• When S = 0 and R = 1, the latch remains in its current state (Q and Q̅ unchanged).
• When S = 1 and R = 0, the latch enters the SET state (Q = 1, Q̅ = 0).
• When both S and R are 0, the latch maintains its previous state.

SR latches are simple but can be problematic due to their potential for indeterminate states (when both S and R are 1), which can lead to unpredictable behavior.

2. D Latch (Data Latch): A D latch is an improvement over the SR latch, addressing the indeterminate state issue by using a single data input (D). It has a Clock (C) input, a Data (D) input, and two outputs, Q and Q̅. The D latch updates its output based on the Data input only when the Clock signal changes. Here’s how it works:

• When C = 0, the outputs remain unchanged regardless of the Data input.
• When C = 1, the Q output follows the Data input (D). The Q̅ output is the complement of Q.

D latches are commonly used for building simple storage elements, but they can still suffer from glitches and timing-related issues.

3. D Flip-Flop (Data Flip-Flop): A D flip-flop is a more advanced storage element that addresses some of the issues present in the D latch. D flip-flops are edge-triggered, meaning they update their outputs only on specific transitions of the Clock signal (either rising edge or falling edge). Here’s how it works:

• When the Clock signal transitions (e.g., rising edge), the Q output takes on the value of the Data input (D) at that moment.

D flip-flops are widely used for sequential logic applications, such as registers and memory elements, because they provide well-defined timing behavior and avoid glitches that can occur in latches.

In summary, SR latches, D latches, and D flip-flops are fundamental components used in digital circuits for storing and manipulating binary data. D flip-flops, in particular, are the most commonly used of the three due to their well-defined behavior and robustness in sequential logic circuits.

ramworks

Applications

SR latches, D latches, and D flip-flops are fundamental building blocks of digital logic circuits, and they find applications in various aspects of modern computer architecture and digital systems. Here are some common applications of these components:

1. Registers: Registers are used to temporarily store data within a CPU. They hold operands for arithmetic and logic operations, intermediate results, and data during processing. Registers often use D flip-flops to store and update data quickly.
2. Memory Elements: SR latches, D latches, and D flip-flops are used to create memory cells in RAM (Random Access Memory) and other types of storage. These memory cells hold data that can be read from and written to during the operation of a computer system.
3. State Machines: Digital systems often have to perform sequences of operations based on their current state and input conditions. State machines can be implemented using flip-flops to store the current state and logic gates to transition between states based on input conditions.
4. Clock Division and Synchronization: Flip-flops are used to divide the clock frequency or synchronize signals in digital circuits. This is important for coordinating different components of a system that may operate at different speeds.
5. Data Transfer and Buffers: D flip-flops can be used to create data buffers that temporarily store data before it’s transferred from one component to another. This helps to manage data flow between components that might operate at different rates.
6. Control Logic: Flip-flops are used in control logic circuits to store control signals and manage the operation of various parts of a system. This includes enabling or disabling specific functionalities based on certain conditions.
7. Pipeline Stages: In processors and other digital systems that use pipelining, D flip-flops are often used to store data between different pipeline stages. This helps to break down complex operations into smaller sequential steps.
8. Memory Addressing: Flip-flops are used in memory address registers to store memory addresses that the CPU wants to access. These registers determine the location in memory from which data will be read or to which data will be written.
9. Counter Circuits: Counters are used in various applications, such as in timers, frequency dividers, and digital clocks. They can be implemented using a sequence of flip-flops that increment or decrement based on clock pulses.
10. Data Synchronization: Flip-flops are used in data synchronization circuits to ensure that data transferred from one domain to another is captured reliably and without issues related to timing mismatches.

These applications highlight the versatility and importance of SR latches, D latches, and D flip-flops in various aspects of digital systems and modern computer architecture. They are the fundamental building blocks that enable the creation of complex digital circuits and systems.

Logic Gates

Logic gates are fundamental building blocks of digital circuits and play a crucial role in modern electronic devices and computer systems. They are electronic devices that perform basic logic operations on binary signals (0s and 1s) and are the foundation of digital logic, enabling the manipulation and processing of digital information.

The behavior of logic gates is defined by their truth tables, which specify the output states based on the input states. The most common logic operations include AND, OR, NOT, XOR (Exclusive OR), and NAND (NOT AND) among others. These gates can be combined to create more complex circuits capable of performing arithmetic, memory, and control functions.

Here’s a brief overview of some common logic gates:

1. AND Gate: The AND gate takes two or more binary inputs and produces a single binary output. It outputs ‘1’ only when all the inputs are ‘1’. Otherwise, the output is ‘0’. The AND gate acts as a logical “conjunction,” meaning it signifies the intersection or combination of conditions. It is symbolized as ‘∧’.
2. OR Gate: The OR gate also takes two or more binary inputs and produces a single binary output. It outputs ‘1’ if at least one input is ‘1’. The OR gate acts as a logical “disjunction,” meaning it signifies the union or alternative conditions. It is symbolized as ‘∨’.
3. NOT Gate (Inverter): The NOT gate takes a single binary input and produces the opposite binary output. It inverts the input signal, transforming ‘1’ to ‘0’ and ‘0’ to ‘1’. The NOT gate is symbolized as ‘¬’ or with a small circle at its input.
4. XOR Gate (Exclusive OR): The XOR gate takes two binary inputs and produces a single binary output. It outputs ‘1’ only when the inputs are different; otherwise, the output is ‘0’. The XOR gate is symbolized as ‘⊕’.
5. NAND Gate (NOT AND): The NAND gate is a combination of the AND gate followed by a NOT gate. It outputs the opposite of the AND gate’s output. In other words, it produces ‘0’ only when all inputs are ‘1’. Otherwise, the output is ‘1’. The NAND gate is symbolized as ‘⇁’.

Logic gates are implemented using transistors, diodes, or other electronic components, depending on the technology used. They are used to construct more complex digital circuits like adders, multiplexers, flip-flops, and registers, which form the basis of CPUs, memory units, and various digital devices.

The combination and arrangement of logic gates in digital circuits allow us to perform computations, store data, execute instructions, and create complex systems that power modern technology. Understanding logic gates is essential for anyone involved in digital electronics, computer engineering, and computer science.

ALU as logic gates

The Arithmetic Logic Unit (ALU) is a hardware component that is typically constructed using a composite of logic gates. Logic gates are the fundamental building blocks of digital circuits and are used to perform logical operations, such as AND, OR, NOT, and XOR, on binary data (0s and 1s).

The ALU is responsible for performing arithmetic operations (addition, subtraction, multiplication, division) and logical operations (AND, OR, XOR, NOT) on binary data within the central processing unit (CPU). It takes input data from registers, performs the specified operation, and produces the result as output.

To implement the ALU, designers use a combination of logic gates such as AND gates, OR gates, XOR gates, NOT gates, and multiplexers. These logic gates are interconnected in a way that enables them to perform the required arithmetic and logical operations on the input data.

For example, to perform addition in the ALU, binary addition circuits are used, which consist of multiple logic gates to add corresponding bits of the input data while considering carry bits. Similarly, to perform logical operations, appropriate combinations of AND, OR, XOR, and NOT gates are utilized.

Modern CPUs can have complex ALUs that support a wide range of operations, including floating-point arithmetic, SIMD (Single Instruction, Multiple Data) instructions, and more. These ALUs consist of larger and more intricate combinations of logic gates to handle the increased complexity of the instructions they can execute.

In summary, the ALU is a hardware component within the CPU, and its design is based on a combination of logic gates to perform arithmetic and logical operations on binary data. It forms a critical part of the CPU, enabling it to execute a wide range of instructions and perform complex computations.

Speed

The CPU clock is defined by hertz because hertz is a unit of frequency, and the CPU clock represents the frequency at which the CPU’s clock generates pulses. In the context of computing, the CPU clock generates a regular and steady stream of electrical pulses, where each pulse represents a clock cycle. The CPU uses these clock cycles to synchronize and regulate its internal operations, including instruction fetch, decode, execution, and data movement.

By measuring the CPU clock in hertz, we can quantify the number of clock cycles the CPU completes in a given time period. For example, a CPU with a clock speed of 3.0 GHz (3 billion hertz) will complete three billion clock cycles per second.

The hertz unit is named after Heinrich Hertz, a German physicist who made significant contributions to the study of electromagnetic waves. Hertz’s work provided crucial evidence for the existence of electromagnetic waves, which laid the foundation for the concept of frequency as cycles per second.

Using hertz to define the CPU clock allows for a standard and straightforward way to measure and compare clock speeds across different CPUs and computing devices. It provides a universally understood unit for expressing how fast a CPU operates and enables meaningful comparisons between processors, regardless of their specific architectures or manufacturers.

CPU speed, often measured in megahertz (MHz) or gigahertz (GHz), refers to the clock frequency at which a central processing unit (CPU) operates. It is a crucial factor in determining a CPU’s performance and how quickly it can process instructions and data.

Clock Frequency and Instruction Execution

The CPU clock is an electronic oscillator that generates a steady and regular pulse, known as a clock cycle. Each clock cycle represents a unit of time during which the CPU can execute an instruction or perform an operation. CPU speed is typically expressed in terms of cycles per second, where 1 Hz (Hertz) equals one cycle per second.

For example, a CPU with a clock speed of 1 GHz operates at one billion cycles per second, while a CPU with a clock speed of 3 GHz operates at three billion cycles per second.

Instruction Execution Time

The clock speed directly impacts the time it takes the CPU to execute an instruction. In general, the lower the clock speed, the longer it takes to execute instructions, and the slower the CPU’s overall performance. On the other hand, higher clock speeds enable faster instruction execution and better overall performance.

However, it is essential to note that CPU performance is not solely determined by clock speed. Other factors, such as the architecture (CISC vs. RISC), the presence of multiple cores, cache size, and the efficiency of the microarchitecture, play significant roles in determining CPU performance.

Instructions Per Clock (IPC)

In modern CPUs, each instruction may require a different number of clock cycles to complete its execution, depending on the complexity of the instruction and the CPU’s microarchitecture. This is known as Instructions Per Clock (IPC) or CPI (Cycles Per Instruction). IPC indicates how many instructions can be executed in a single clock cycle, and a higher IPC means better performance.

For instance, a CPU with a clock speed of 3 GHz and an IPC of 2 would effectively execute instructions at a rate of 6 billion instructions per second (3 GHz × 2 IPC).

Improvements in CPU Speed Over Time

CPU clock speeds have seen significant improvements over the years due to advancements in semiconductor manufacturing processes and microarchitecture design. In the early days of computing, CPUs operated at clock speeds in the range of a few megahertz (MHz). As technology progressed, clock speeds reached into the gigahertz (GHz) range, and some high-end processors even surpassed 5 GHz.

It is essential to consider that simply comparing CPU clock speeds between different processor generations or manufacturers may not provide an accurate measure of performance. Modern CPUs often incorporate multiple cores, simultaneous multithreading (SMT), and other architectural enhancements, which contribute to improved performance even at similar clock speeds.

The concept of “more GHz equals better performance” is no longer a straightforward rule, as various factors, including parallelism, cache efficiency, and the number of cores, impact overall CPU performance. Therefore, comparing benchmark results and real-world performance tests is crucial to understanding how CPUs perform in different scenarios.

Pipelining

CPU pipelining is a technique used in modern computer processors to improve their performance by overlapping the execution of multiple instructions. It allows the CPU to execute several instructions in parallel, thereby increasing the overall throughput and reducing the time required to complete a sequence of instructions.

In a pipelined CPU, the execution of an instruction is broken down into a series of stages, and each stage represents a specific operation in the instruction execution process. These stages are executed one after the other, and at any given time, multiple instructions can be in different stages of the pipeline.

The classic five-stage pipeline consists of the following stages:

1. Instruction Fetch (IF): The CPU fetches the next instruction from memory based on the program counter (PC) value.
2. Instruction Decode (ID): The fetched instruction is decoded to determine the operation to be performed and the operands involved.
3. Execution (EX): The CPU performs the actual operation or computation specified by the instruction.
4. Memory Access (MEM): If the instruction involves memory access (e.g., load or store), this stage fetches or stores data from/to memory.
5. Write Back (WB): The result of the operation is written back to the appropriate destination register.

Each instruction moves through the pipeline, and as soon as one instruction completes one stage, the next instruction can enter that stage. As a result, different instructions are at different stages of execution simultaneously, and the pipeline is always filled with instructions, maximizing the utilization of CPU resources.

Benefits of CPU Pipelining

1. Increased Throughput: Pipelining allows the CPU to handle multiple instructions at once, effectively increasing the number of instructions processed per unit of time.
2. Reduced Latency: Pipelining reduces the time it takes to complete a single instruction since multiple instructions are partially completed simultaneously.
3. Better Resource Utilization: With pipelining, the CPU’s hardware resources, such as ALU (Arithmetic Logic Unit) and registers, are better utilized, improving overall efficiency.
4. Efficient Use of Cycle Time: In a non-pipelined CPU, some stages of instruction execution might be idle during certain cycles. Pipelining ensures that each stage is active in every cycle.

Challenges and Hazards

While pipelining significantly enhances CPU performance, it introduces challenges known as hazards, which can reduce its efficiency. Common types of hazards include:

1. Structural Hazards: Occur when multiple instructions need the same hardware resource simultaneously.
2. Data Hazards: Arise when one instruction depends on the result of a previous instruction still in the pipeline.
3. Control Hazards: Arise due to branch instructions that change the flow of program execution, affecting the accuracy of instruction fetch and causing pipeline stalls.

Pipelined CPUs use various techniques, such as forwarding (also known as data forwarding or data hazard forwarding) and branch prediction, to mitigate the impact of hazards and improve performance further.

Comparison with OS process management

Pipelining in CPUs and processes/threads in operating systems are related concepts, but they operate at different levels within a computer system. The connection between pipelining and processes or threads is outlined below:

1. Pipelining in CPUs: CPU pipelining is a microarchitecture technique that allows the CPU to execute multiple instructions in parallel by breaking down the instruction execution process into stages. Each stage handles a specific operation, and different instructions are in various stages of execution simultaneously. Pipelining enhances CPU performance by maximizing the utilization of hardware resources and improving instruction throughput.
2. Processes and Threads in Operating Systems: In the context of operating systems, a process is a unit of execution that represents a running program. A process contains the program’s code, data, and resources, and it operates independently of other processes. Within a process, multiple threads can be created. A thread is a smaller unit of execution that belongs to a process and shares the same resources, such as memory and file descriptors, with other threads in the same process. Threads allow for concurrent execution within a single process.

How Pipelining Relates to OS Processes and Threads

1. Parallelism: Pipelining and processes/threads both aim to achieve parallelism, which is the execution of multiple tasks concurrently to improve efficiency and performance.
2. Instruction-Level Parallelism (ILP): Pipelining focuses on executing multiple instructions from a single program concurrently. Each instruction goes through the pipeline stages, and at any given time, different instructions are in different stages of execution. This concept of instruction-level parallelism enhances the performance of a single program.
3. Thread-Level Parallelism (TLP): In the context of processes and threads, thread-level parallelism involves executing multiple threads of the same or different processes concurrently. Threads share resources within a process, and multiple threads can run independently, performing different tasks simultaneously. This increases the overall throughput and responsiveness of the system.
4. Resource Management: Just as pipelining requires careful management of hardware resources to prevent hazards, processes and threads need effective resource management to avoid conflicts and ensure efficient utilization of system resources.
5. Synchronization and Coordination: Pipelining requires mechanisms to handle hazards and ensure that instructions are executed in the correct order. Similarly, processes and threads often require synchronization and coordination mechanisms to manage access to shared resources and avoid race conditions.
6. Context Switching: Context switching, a crucial operation in operating systems, involves saving the state of a running process/thread and restoring the state of another process/thread. Context switching ensures fairness and multitasking. While pipelining doesn’t directly involve context switching, both concepts contribute to the overall system’s multitasking capabilities.

In summary, pipelining and processes/threads are related through the broader concepts of parallelism and concurrency. Pipelining focuses on instruction-level parallelism within a single program, while processes and threads provide a framework for achieving thread-level parallelism across multiple programs. Both concepts contribute to improving the efficiency and performance of modern computer systems.

Modern architectures

Asahi Linux

is there an eficheck tool for arm macs.2289446

ARM and Intel are two different computer architectures used in various devices, each with its own strengths and target applications. Here are the main differences between ARM and Intel architectures:

1. Instruction Set Architecture (ISA):
   * ARM (Advanced RISC Machines): ARM processors use a RISC (Reduced Instruction Set Computing) architecture. They have a simplified and streamlined instruction set, which typically leads to lower power consumption and greater efficiency in specific tasks.
   * Intel: Intel processors use a CISC (Complex Instruction Set Computing) architecture. CISC processors have more complex instructions that can perform more operations in a single instruction but may require more power and time.
2. Power Efficiency:
   * ARM: ARM processors are known for their power efficiency and are commonly used in mobile devices, IoT devices, and embedded systems. They are designed to maximize performance per watt, making them suitable for battery-powered devices.
   * Intel: Intel processors, especially those used in desktops and laptops, tend to consume more power compared to ARM processors. However, Intel has made advancements in power efficiency in recent years.
3. Performance:
   * ARM: While ARM processors excel in power efficiency, they traditionally lagged behind Intel’s x86 processors in raw performance for high-intensity computing tasks. However, with the continuous development of ARM-based designs, the performance gap has been narrowing, especially with the emergence of custom ARM designs like Apple’s M1 chip.
   * Intel: Intel processors, especially in their high-end desktop and server lines, have been dominant in terms of raw processing power for many years. They are often used in PCs, workstations, and data centers for intensive tasks.
4. Application Domains:
   * ARM: ARM processors are prevalent in mobile devices (smartphones, tablets), IoT devices, embedded systems, microcontrollers, and various low-power applications. They are also increasingly used in laptops and servers, especially for specific workloads like cloud computing and AI.
   * Intel: Intel processors have historically been dominant in the PC market, including desktops, laptops, and workstations. They are also widely used in servers, data centers, and high-performance computing applications.
5. Ecosystem and Software Compatibility:
   * ARM: ARM-based devices may require specific software tailored for the ARM architecture, although many popular applications are now available for ARM. Additionally, virtualization and emulation technologies have improved compatibility.
   * Intel: Intel processors benefit from a vast software ecosystem built around the x86 architecture, ensuring broad software compatibility across various platforms.

Available computer architectures include:

• ARM: ARMv8-A, ARMv7-A, ARMv6-M, etc.
• Intel: x86 (IA-32), x86-64 (Intel 64), etc.

It’s worth noting that the lines between ARM and Intel are blurring, as both companies are exploring new markets and technologies. For instance, Intel has been working on power-efficient designs for mobile devices, while ARM-based processors are making significant strides in the high-performance computing realm. Additionally, other computer architectures, such as RISC-V, are gaining traction as open-source alternatives.

1. ARM:

ARM (Advanced RISC Machines) is a family of CPU architectures developed by ARM Holdings (now Arm Limited), a British semiconductor and software design company. ARM processors are based on the RISC (Reduced Instruction Set Computing) design philosophy, which focuses on simplicity and efficiency. The ARM architecture has evolved over the years, leading to various versions, with the most notable ones being ARMv8-A, ARMv7-A, and ARMv6-M.

• ARMv8-A: ARMv8-A is the latest version of the ARM architecture, which introduced support for 64-bit processing, along with backward compatibility for 32-bit (AArch32) applications. It brought significant enhancements, including a larger number of general-purpose registers, improved security features like TrustZone, and hardware virtualization support (Virtualization Extensions). ARMv8-A processors are commonly found in smartphones, tablets, laptops, servers, and other devices that require a balance of performance and power efficiency. Notable implementations of ARMv8-A include the Apple M1 chip, Qualcomm Snapdragon 8 series, and many others.
• ARMv7-A: ARMv7-A is an older version of the ARM architecture, primarily supporting 32-bit processing. It was widely used in various smartphones, tablets, and embedded systems before the transition to ARMv8-A. ARMv7-A introduced several important features like Thumb-2 instruction set (a mix of 16-bit and 32-bit instructions), SIMD (Single Instruction, Multiple Data) extensions (NEON), and hardware floating-point support. Notable implementations include the ARM Cortex-A7, Cortex-A9, and Cortex-A15.
• ARMv6-M: ARMv6-M is designed for microcontroller applications and targets low-power and cost-sensitive devices. It is based on the ARMv6 architecture and is commonly used in IoT devices, wearables, and other embedded systems. ARMv6-M processors typically have a reduced instruction set, fewer registers, and limited resources compared to higher-end ARM architectures like ARMv8-A.

2. Intel:

Intel is a leading American semiconductor company known for its x86 (IA-32) and x86-64 (Intel 64) architectures. The x86 architecture traces its roots back to the Intel 8086 processor, released in 1978. It became the de facto standard for personal computers and is widely used in desktops, laptops, workstations, servers, and data centers. The two most significant versions of the x86 architecture are:

• x86 (IA-32): The original 32-bit version of the x86 architecture is commonly referred to as IA-32 (Intel Architecture 32-bit). IA-32 processors feature a complex instruction set with variable-length instructions. It includes a set of general-purpose registers, special-purpose registers, and supports privileged modes for operating system operations. The IA-32 architecture has undergone numerous extensions and improvements over the years, enabling increased performance and expanded capabilities. However, it has limitations in addressing memory beyond 4 GB.
• x86-64 (Intel 64): x86-64, also known as Intel 64 or AMD64, is an extension of the x86 architecture that introduced 64-bit support while maintaining backward compatibility with 32-bit software (through compatibility mode). It was jointly developed by Intel and AMD, and it significantly expanded the addressable memory space, allowing systems to access terabytes of memory. The introduction of x86-64 enabled improved performance for memory-intensive applications and paved the way for a new era of 64-bit computing. The x86-64 architecture is now the dominant standard for desktop and server computing. Notable implementations include Intel Core i series and AMD Ryzen processors.

Both ARM and Intel architectures have their strengths and cater to different markets. ARM is widely used in mobile devices and embedded systems, emphasizing power efficiency and portability, while Intel’s x86 processors dominate the PC and server market, offering high performance and broad software compatibility.

AMD (Advanced Micro Devices) is another major semiconductor company known for its x86 and x86-64 architectures, similar to Intel. AMD’s processors are commonly found in various computing devices, including desktops, laptops, and servers. The AMD architecture is outlined in more detail below:

1. x86 (IA-32):

AMD’s initial processors were compatible with Intel’s x86 architecture. AMD’s first x86 processor, the AMD Am386, was released in 1991. AMD followed Intel’s lead and developed processors based on the same x86 ISA, making them compatible with software designed for Intel’s processors. These processors were part of the IA-32 (Intel Architecture 32-bit) family.

AMD’s x86 processors offered similar performance to Intel’s offerings at competitive prices, making them a popular choice among consumers and businesses alike.

2. x86-64 (AMD64):

One of the most significant contributions from AMD to the computer architecture landscape is the x86-64 architecture, also known as AMD64. AMD introduced this 64-bit extension to the existing x86 ISA in 2003 with the release of its AMD Opteron processors. This extension was developed jointly by AMD and Intel but was first implemented by AMD.

The x86-64 architecture addressed the limitations of the 32-bit address space by enabling systems to access much larger memory spaces (up to 2^64 bytes or 16 exabytes) compared to the 4 GB limit of IA-32. This advancement paved the way for improved performance in memory-intensive applications and allowed for more efficient handling of large datasets.

Importantly, AMD’s x86-64 architecture maintained backward compatibility with 32-bit software, ensuring that existing applications could run on the new 64-bit processors without modification.

Intel subsequently adopted the x86-64 architecture and branded it as “Intel 64,” leading to widespread adoption of 64-bit computing across both AMD and Intel processor lines.

3. Zen Microarchitecture:

AMD’s Zen microarchitecture is a major advancement in their processor designs, which was first introduced in 2017 with the release of AMD Ryzen processors. Zen brought significant improvements in performance, power efficiency, and scalability.

Key features of the Zen microarchitecture include:

• Simultaneous Multithreading (SMT): Similar to Intel’s Hyper-Threading, SMT enables each physical CPU core to handle multiple software threads simultaneously, enhancing overall performance in multi-threaded workloads.
• Improved Branch Prediction: Zen introduced an advanced branch predictor, reducing the number of mispredicted branches and improving instruction throughput.
• Wider Execution Units: Zen processors have wider execution units, enabling them to process more instructions in parallel.
• Enhanced Cache Hierarchy: Zen processors have an improved cache hierarchy, providing faster access to frequently used data and instructions.

AMD’s Zen microarchitecture has been used in subsequent processor generations, including Zen 2, Zen 3, and Zen 4, which have continued to deliver performance improvements and power efficiency gains.

In summary, AMD’s architecture includes both x86 and x86-64 instruction set architectures. AMD’s contributions, particularly the x86-64 architecture and the Zen microarchitecture, have been instrumental in driving innovation and competition in the processor market. This competition has been beneficial for consumers, as it has led to more choices, improved performance, and competitive pricing across the computing industry.

Intel processors brief history

The term “x86” refers to a family of instruction set architectures (ISAs) used by Intel and compatible processors. The name “x86” is derived from the original names of some of Intel’s early microprocessors. The history behind the x86 nomenclature is outlined below:

In the late 1970s, Intel developed its first 16-bit microprocessor, known as the Intel 8086, which was released in 1978. The 8086 was a significant step forward in microprocessor technology and paved the way for the modern x86 architecture.

The Intel 8086 had a 16-bit ISA, which means it could process data and instructions in 16-bit chunks. Its successors, the Intel 80186 and Intel 80286, followed a similar 16-bit architecture, and all three processors were collectively referred to as the “x86” family.

In the mid-1980s, Intel introduced the Intel 80386 microprocessor, also known as the 386. This was a major milestone in the evolution of the x86 architecture because it introduced a 32-bit ISA. The 80386 was fully backward-compatible with the 16-bit instructions of its predecessors, allowing it to run existing x86 software while also providing enhanced capabilities for 32-bit applications. The introduction of 32-bit capabilities made the term “x86” increasingly associated with both 16-bit and 32-bit processors.

Over time, as Intel continued to develop more powerful microprocessors with each new generation, they retained the x86 architecture and expanded it with additional features. This led to the development of the 80486 (486), Pentium, Pentium II, and subsequent processor families.

As a result, the name “x86” became a catch-all term encompassing the whole lineage of Intel’s microprocessors and compatible processors based on the same instruction set. The “x” in x86 stands for “extended,” indicating the architecture’s ability to extend from 16-bit to 32-bit and beyond.

Today, the x86 architecture continues to be a dominant force in the computing industry, powering a vast majority of desktop and laptop computers, servers, and data centers. It is also worth noting that AMD, another major processor manufacturer, has developed compatible processors using the x86 architecture, further solidifying its widespread adoption.

Hardware Security

Security breaches explored through hardware architecture have become an increasingly significant concern in the realm of cybersecurity. Attackers have developed various techniques to exploit vulnerabilities in hardware components to compromise system integrity, steal data, and gain unauthorized access. Here are some notable examples:

1. Meltdown and Spectre (2018): These are perhaps the most well-known hardware vulnerabilities. They are both side-channel attacks that take advantage of speculative execution in modern processors. Meltdown allows an attacker to access kernel memory from user space, while Spectre enables an attacker to trick a program into leaking sensitive information.
2. Rowhammer (2014): Rowhammer is a memory-related vulnerability that leverages the physical properties of DRAM cells. By rapidly accessing specific memory rows, an attacker can cause bit flips in adjacent rows, leading to data corruption and potential privilege escalation.
3. Rogue System Register Read (2015): This attack targets Intel processors by exploiting certain side effects of speculative execution. It enables an attacker to leak information across privilege levels, potentially compromising the integrity of the system.
4. USB-Based Attacks (e.g., BadUSB): These attacks involve manipulating the firmware of USB devices to execute malicious actions once connected to a computer. Attackers can modify the behavior of USB devices to act as keyboard emulators or network interfaces, potentially gaining control over the host system.
5. Intel Management Engine (IME) Exploits: IME is a separate microcontroller built into Intel processors, which can have full control over a system. Exploits targeting IME can allow attackers to gain unauthorized access to the system, bypass security mechanisms, and potentially install persistent malware.
6. Firmware-Level Attacks: Attackers can compromise the firmware of various hardware components such as BIOS, UEFI, and device drivers. Once compromised, attackers can gain control over the boot process and have persistent access to the system.
7. Side-Channel Attacks (e.g., Cache Timing Attacks): Side-channel attacks target the information leaked through unintended channels, such as cache access patterns. By analyzing the timing or power consumption of these channels, attackers can infer sensitive data like cryptographic keys.
8. Trusted Platform Module (TPM) Exploits: TPM is a hardware component designed to enhance system security by providing secure storage for cryptographic keys and measurements. However, vulnerabilities in TPM implementations can be exploited to compromise system security.
9. Hardware Trojans: Malicious modifications can be introduced into the hardware design or manufacturing process. These hardware Trojans can be triggered under specific conditions to leak data, disrupt operations, or provide unauthorized access.
10. Cold Boot Attacks: Cold boot attacks involve extracting sensitive data from a system’s RAM after it has been powered off but is still retaining data for a brief period. This attack exploits the data remanence property of RAM.
11. Power Analysis Attacks: By monitoring the power consumption of a hardware device, attackers can gain insights into its internal operations, potentially revealing sensitive information such as encryption keys.

To defend against these hardware-based security breaches, hardware manufacturers and software developers are continuously working to implement security mechanisms like hardware-enforced isolation, secure boot processes, and more robust encryption techniques. Additionally, researchers and the cybersecurity community at large are essential in identifying and reporting vulnerabilities, leading to timely patches and mitigations.

Persistent Attack Vectors on Local WiFi Networks in 2025

Even in 2025, with widespread adoption of WPA3 and improved encryption standards, joining a WiFi network (e.g., via a shared password or guest access) still exposes users to significant risks on the local area network (LAN). Attackers can leverage layer 2/3 protocols, unpatched devices, and misconfigurations for interception, lateral movement, and exploitation. Classic techniques like ARP + DNS spoofing for Man-in-the-Middle (MitM) attacks have diminished effectiveness against modern browsers due to HTTP Strict Transport Security (HSTS) preloading, which enforces HTTPS and blocks self-signed certificates. However, they remain viable in legacy environments, internal networks, or non-web traffic. Below is a summary of key attack vectors that persist, based on current security analyses.

These vectors are particularly risky in home, small office, or public WiFi settings where segmentation and monitoring are lax. Enterprise networks with microsegmentation and zero-trust models fare better, but consumer adoption lags. Always use a VPN on shared networks to tunnel traffic externally. For the latest threats, consult resources like OWASP or NIST guidelines.

Technical/Hardware-Level Attack Vectors for Desktop Payloads in 2025

In 2025, desktop payload delivery via purely technical exploits (bypassing user interaction like phishing) relies on zero-day or n-day vulnerabilities in OS kernels, drivers, browsers, graphics components, and hardware-firmware interfaces. These enable remote code execution (RCE), privilege escalation (EoP), or sandbox escapes, often chaining flaws for initial access and payload deployment (e.g., RATs, ransomware). Drive-by exploits via malicious sites or network protocols remain key, exploiting unpatched systems. Browser zero-days dominate due to widespread exposure, while kernel/driver bugs allow post-compromise escalation. Hardware-side channels and firmware persist despite mitigations. Below are persistent vectors, based on in-the-wild exploits and conference disclosures (e.g., Black Hat/DEF CON 2025).

These vectors shift toward AI-fuzzed zero-days and firmware, with exploitation windows shrinking to hours. Defenses: Zero-trust (e.g., HVCI, VBS), auto-patching, EDR with memory protection, and browser isolation. Monitor CISA KEV and vendor advisories—2025 saw record zero-days in Windows/Chrome/Linux kernels. For enterprises, prioritize kernel hardening and threat hunting.

Computing and materials

Building a computer at a large scale that mimics microprocessors and semiconductors but avoids microscopic-level engineering is an interesting thought experiment. The speed of such a system would depend on several factors, including the materials used, the scale of the components, the architecture, and the alternative mechanisms employed to replicate the functionality of transistors and integrated circuits. Let’s break it down:

Key Considerations

1. Scale and Materials:
   * Microprocessors rely on nanoscale transistors (e.g., 3nm or 5nm process nodes in 2025) that switch at incredibly high speeds (gigahertz range). Scaling up to macroscopic components (e.g., centimeters or meters) would inherently slow down operations due to increased distances for signal propagation.
   * Alternative materials (e.g., mechanical relays, vacuum tubes, fluidic circuits, or optical components) would replace silicon-based transistors. Each has different switching speeds and energy efficiencies:
   • Mechanical relays: Extremely slow (milliseconds per switch, \~1-10 Hz).
   • Vacuum tubes: Faster (microseconds, \~kHz to low MHz range).
   • Fluidic or pneumatic systems: Very slow (seconds to milliseconds).
   • Optical systems: Potentially fast (nanoseconds, approaching GHz), but bulky and complex for large-scale logic.
   • Memristors or other macro-scale electronic components: Could approach semiconductor speeds but still slower due to size and resistance.
2. Signal Propagation:
   * In microprocessors, signals travel short distances (nanometers to micrometers) at near-light speeds. In a large-scale system, signals might travel centimeters or meters, introducing significant latency. For example, electrical signals in copper wires travel at \~2/3 the speed of light, but longer distances increase delays (e.g., 1 meter introduces \~5 ns latency).
   * Optical systems could mitigate this by using light for data transfer, but the switching mechanisms would still be slower than nanoscale transistors.
3. Parallelism and Architecture:
   * Microprocessors achieve high performance through massive parallelism (billions of transistors). A large-scale system could theoretically replicate this with many parallel components, but the physical size would make synchronization and heat dissipation challenging.
   * The architecture would likely resemble older, simpler computers (e.g., ENIAC or mechanical computers like Babbage’s Analytical Engine) rather than modern CPUs, limiting computational complexity.
4. Energy Efficiency:
   * Microprocessors are efficient due to their small size and low power requirements per transistor. Large-scale systems would consume vastly more power, potentially limiting clock speeds to manage heat and energy costs.

Estimated Speed

• Mechanical Systems: A computer using mechanical relays (like early 20th-century computers) would operate in the range of 1–100 operations per second (Hz). For example, the Harvard Mark I (1944), a relay-based computer, performed \~3 additions per second.
• Vacuum Tubes: A vacuum tube-based system (like the ENIAC, 1945) could achieve \~100,000 operations per second (100 kHz), but this is still orders of magnitude slower than modern CPUs (\~3–5 GHz, or billions of operations per second).
• Optical or Macro-Electronic Systems: If advanced materials like optical switches or macro-scale memristors were used, speeds might approach 1–100 MHz in an optimistic scenario, but this assumes highly efficient designs and fast-switching components.
• Comparison to Modern CPUs: A modern microprocessor (e.g., Intel Core i9 or AMD Ryzen, 2025) operates at 3–6 GHz with billions of transistors, performing trillions of operations per second (teraflops). A large-scale alternative would likely be 10^6 to 10^9 times slower, depending on the technology.

Practical Examples

• Historical Context: The ENIAC, using vacuum tubes, was \~1,000x slower than early silicon computers. A large-scale system using similar principles would be even slower due to size constraints.
• Hypothetical Optical System: If you used optical switches (e.g., liquid crystal or photonic gates), you might achieve speeds closer to MHz, but the system would be massive, expensive, and complex to maintain.
• Biological or Chemical Alternatives: Systems mimicking neural networks with chemical or biological components (e.g., DNA computing) could theoretically perform parallel computations but would be extremely slow for general-purpose computing (\~seconds per operation).

Limitations

• Size vs. Speed Tradeoff: Larger components mean longer signal paths, increasing latency and reducing clock speeds.
• Complexity: Microprocessors pack billions of transistors into a square centimeter. Replicating this complexity with large-scale components would require infeasible amounts of space and materials.
• Heat and Power: Larger systems would generate more heat and require more power, further limiting performance.

Conclusion

A large-scale computer avoiding microscopic engineering would likely operate in the range of 1 Hz to 100 MHz, depending on the technology (mechanical, vacuum tube, optical, etc.). This is millions to billions of times slower than modern microprocessors. For context, a 100 MHz large-scale system would perform like a 1980s-era PC, while a mechanical system would be closer to a 1940s computer. To approach modern speeds, you’d need highly advanced macroscopic technologies (e.g., photonic circuits) and massive parallelism, but even then, it would struggle to match the efficiency and density of nanoscale silicon.

Alternative computing paradigms

Alternative computing paradigms that reduce operations or bypass traditional von Neumann architectures (like those in microprocessors) aim to achieve efficiency by rethinking how computation is performed. These approaches often prioritize parallelism, energy efficiency, or novel physical principles to minimize the number of operations or their complexity. Below is an overview of key alternative computing methods discovered or developed as of August 2025, based on current trends and research:

1. Quantum Computing

• Concept: Uses quantum bits (qubits) that exist in superpositions of states (0 and 1 simultaneously), enabling parallel computation for specific problems. Quantum algorithms (e.g., Shor’s, Grover’s) can reduce the number of operations for tasks like factoring, optimization, and search.
• Operation Reduction:
• Shor’s algorithm for factoring large numbers is exponentially faster than classical algorithms (e.g., reduces operations from O(2^n) to O(n^3)).
• Grover’s algorithm provides a quadratic speedup for unstructured search (O(√N) vs. O(N)).
• Progress:
• As of 2025, companies like IBM, Google, and Quantinuum have quantum computers with 100–1,000 qubits, but they are noisy and limited to specific tasks (e.g., quantum simulation, optimization).
• Error-corrected quantum computing is still in development, with practical large-scale systems likely a decade away.
• Challenges: Limited to niche problems; requires complex error correction and cryogenic systems.

2. Neuromorphic Computing

• Concept: Mimics the human brain’s neural structure, using spiking neural networks or analog circuits to process data in a highly parallel, event-driven manner. This reduces operations for tasks like pattern recognition and machine learning.
• Operation Reduction:
• Instead of sequential operations, neuromorphic chips process inputs in parallel, reducing the need for millions of floating-point operations in traditional neural networks.
• Energy efficiency is 10–1,000x better than GPUs for specific AI tasks.
• Progress:
• Intel’s Loihi 2 and IBM’s TrueNorth are neuromorphic chips with applications in edge AI, robotics, and sensory processing.
• Recent advances (2025) include hybrid neuromorphic systems integrated with traditional processors for real-time tasks like autonomous driving.
• Challenges: Limited to specific applications; general-purpose computing is less efficient.

3. Analog Computing

• Concept: Uses continuous physical quantities (e.g., voltages, currents) to perform computations, avoiding discrete binary operations. Ideal for solving differential equations or simulating physical systems.
• Operation Reduction:
• Analog systems can solve complex problems (e.g., differential equations) in a single step, compared to thousands of iterative digital operations.
• Energy consumption is lower for specific tasks like signal processing or physics simulations.
• Progress:
• Companies like Mythic AI and Aspinity are developing analog chips for low-power AI and sensor applications.
• Recent research (2025) explores analog in-memory computing, where computations occur directly in memory, reducing data movement (a major bottleneck in von Neumann architectures).
• Challenges: Susceptible to noise; less precise for general-purpose computing.

4. Optical/Photonic Computing

• Concept: Uses light (photons) instead of electrons for computation, leveraging parallelism and high-speed signal propagation (near speed of light).
• Operation Reduction:
• Optical systems can perform matrix multiplications (common in AI) in a single step using wave interference, compared to thousands of operations on CPUs/GPUs.
• Reduces energy costs for data transfer in large-scale systems.
• Progress:
• Startups like Lightmatter and Optalysys are developing photonic chips for AI and high-performance computing.
• Recent breakthroughs (2025) include integrated photonic circuits for neural network acceleration, achieving 10x energy efficiency over GPUs.
• Challenges: Bulky hardware; limited to specific tasks like linear algebra or AI.

5. Memristor-Based Computing

• Concept: Uses memristors (memory-resistors) that retain state, enabling in-memory computing. This reduces operations by combining memory and processing, eliminating data transfer bottlenecks.
• Operation Reduction:
• Matrix operations for machine learning can be performed in O(1) time per layer, compared to O(n^2) or higher in traditional systems.
• Analog-like behavior allows efficient neural network training.
• Progress:
• Companies like Crossbar and academic research (e.g., Stanford, MIT) are advancing memristor arrays for neuromorphic and AI applications.
• In 2025, memristor-based chips are being tested for edge computing, with prototypes showing 100x energy efficiency over traditional hardware for specific tasks.
• Challenges: Scalability and reliability issues; still in early stages.

6. DNA/Biochemical Computing

• Concept: Uses DNA molecules or biochemical reactions to perform computations, leveraging massive parallelism at the molecular level.
• Operation Reduction:
• DNA computing can solve combinatorial problems (e.g., traveling salesman) in fewer steps by exploiting parallel chemical reactions.
• A single DNA strand can represent multiple states, reducing the need for sequential operations.
• Progress:
• Research (e.g., Caltech, 2025) demonstrates small-scale DNA circuits for pattern recognition and optimization.
• Limited to lab-scale experiments; practical applications are decades away.
• Challenges: Extremely slow (seconds to hours per operation); not suitable for real-time computing.

7. Adiabatic/Reversible Computing

• Concept: Designs circuits to minimize energy loss by making computations reversible, reducing the thermodynamic cost of operations.
• Operation Reduction:
• Reduces energy per operation, allowing more computations within the same power budget.
• Can simplify certain algorithms by reusing intermediate states.
• Progress:
• Mostly theoretical, with some experimental prototypes in academia (e.g., University of Notre Dame, 2025).
• Limited practical implementations due to complex circuit design.
• Challenges: Slow and impractical for general-purpose computing.

8. Topological Computing

• Concept: Uses topological properties of materials (e.g., topological insulators or quantum states) to perform robust computations resistant to noise.
• Operation Reduction:
• Potentially reduces error-correction overhead in quantum-like systems.
• Simplifies certain computations by encoding data in stable topological states.
• Progress:
• Early-stage research (2025) focuses on topological quantum computing (e.g., Microsoft’s work on Majorana fermions).
• No practical systems yet; highly theoretical.
• Challenges: Requires exotic materials and extreme conditions (e.g., near-absolute zero temperatures).

9. Stochastic/Probabilistic Computing

• Concept: Uses randomness or probabilistic methods to simplify computations, especially for optimization or machine learning.
• Operation Reduction:
• Monte Carlo methods or stochastic rounding can reduce the number of precise operations needed for approximate computing tasks.
• Efficient for problems like Bayesian inference or neural network training.
• Progress:
• Used in niche applications like cryptography and AI (e.g., Google’s TPUs incorporate stochastic elements).
• Research (2025) explores stochastic circuits for ultra-low-power devices.
• Challenges: Limited to approximate computing; not suitable for precise tasks.

Large-Scale Alternatives (Macroscopic Systems)

Since your previous question focused on avoiding microscopic engineering, some of these paradigms could theoretically be implemented at a larger scale:

• Optical Computing: Macro-scale optical systems (e.g., using lenses, mirrors, or liquid crystals) could perform parallel computations but would be bulky and slow (\~kHz to MHz).
• Fluidic Computing: Uses fluid flows or pressure to mimic logic gates. Historically explored (e.g., 1960s FLUIDICS), these systems are slow (\~Hz) but could be built at a macroscopic scale.
• Mechanical Computing: Large-scale mechanical systems (e.g., Babbage’s Analytical Engine or modern LEGO-based computers) are extremely slow (\~1–10 Hz) but avoid microengineering.

Current State (2025)

• Most Promising: Neuromorphic, optical, and memristor-based computing are closest to practical deployment, especially for AI and edge applications. They reduce operations for specific tasks by 10–1,000x compared to traditional CPUs/GPUs.
• Macro-Scale Feasibility: Optical and fluidic systems are feasible at larger scales but would be orders of magnitude slower and less efficient than silicon-based systems. Mechanical systems are mostly impractical for modern computing needs.
• Research Trends: Recent X posts and web sources (e.g., academic papers, tech blogs) highlight growing investment in neuromorphic and photonic chips, with companies like Intel, NVIDIA, and Lightmatter pushing commercialization. Quantum computing remains a long-term goal.

Conclusion

Alternative computing paradigms like quantum, neuromorphic, optical, and memristor-based systems offer ways to reduce operations for specific tasks, often by leveraging parallelism or novel physical principles. However, at a large scale without microscopic engineering, options like optical or fluidic computing are limited to \~kHz–MHz speeds and niche applications. For general-purpose computing, these systems are impractical compared to silicon microprocessors. If you’re interested in a specific paradigm or application (e.g., AI, optimization).

FPGAs

They are fundamentally different types of chips, even though both are made of transistors on silicon. Here’s a clear breakdown:

1. What is a CPU?

• Fixed hardware (hard-wired logic).
• Designed and manufactured with a permanent architecture (e.g., x86, ARM, RISC-V).
• Once fabricated, the logic gates and instruction set are impossible to change without replacing the chip.
• Examples: Intel Core i9, AMD Ryzen, Apple M4, Qualcomm Snapdragon.

2. What is an FPGA?

• Field-Programmable Gate Array.
• Contains millions of configurable logic blocks (CLBs) and programmable interconnects.
• You can reprogram the hardware itself after manufacturing — as many times as you want — using HDL (Verilog/VHDL).
• The chip physically reconfigures its internal wiring to implement any digital circuit (CPU, GPU, crypto miner, DSP, etc.).
• Examples: Xilinx (AMD) Versal, Intel Agilex, Lattice ECP5, Gowin GW1N.

3. Key differences

4. Can an FPGA act like a CPU?

Yes! You can implement a full CPU inside an FPGA (e.g., RISC-V soft cores like Rocket Chip, PicoRV32, or even x86 clones).
But the FPGA itself is not a CPU — it’s a blank slate that can become a CPU (or anything else) when programmed.

5. Are there any “in-between” chips?

Yes, sort of:

• Intel CPUs with integrated FPGA (e.g., older Arria 10/Stratix 10 packages with Xeon on the same die).
• AMD Xilinx Versal with hard ARM cores + FPGA fabric. But even here, the CPU part is fixed silicon, and the FPGA part is programmable — they are still distinct.

Bottom line

Today’s CPUs are fixed-function ASICs (Application-Specific Integrated Circuits), not FPGAs.
FPGAs are the opposite: universal hardware that can become any circuit, including a CPU.

If someone calls a modern CPU an FPGA, they’re simply wrong — it’s like calling a printed book a blank notebook.

Crypto and AI

Great questions! Let’s clear up the confusion step by step.

1. Why FPGAs are used for AI and Crypto despite being slower in clock speed

FPGAs rarely run at >1 GHz, while CPUs/GPUs run at 3–6 GHz.
But raw clock speed is not what matters for AI or crypto mining. What matters is:

Real numbers (2024–2025):

• A single AMD Versal VP1902 FPGA delivers \~1.3 Peta-Ops INT4 for AI → rivals an NVIDIA H100 on some inference workloads while using 1/4 the power.
• Bitstream (Bitcoin) FPGAs in 2012–2013 already out-hashed every GPU on the planet because they had 2000+ parallel SHA-256 pipelines.

Bottom line: FPGAs trade clock speed for massive parallelism + custom data paths + bit-level efficiency. That’s why they dominate low-latency AI inference and once ruled crypto mining.

2. How can a physical circuit literally “change itself”?

This is the magic of FPGA fabric. Here’s exactly what physically happens inside the chip:

a) The three reconfigurable parts

1. Configurable Logic Blocks (CLBs)
   * Each CLB contains a small LUT (Look-Up Table — basically a 6–8 input truth table stored in SRAM).
   * 64-bit SRAM = 2⁶ = 64 different functions. By changing the SRAM bits you instantly turn one gate into AND, OR, XOR, a full adder, part of a multiplier, etc.
2. Programmable interconnect (switch matrices)
   * Thousands of tiny SRAM-controlled transistors act like railroad switches.
   * Changing one SRAM bit literally opens or closes a physical wire path.
3. Block RAM + DSP slices
   * Can be configured as 18×18 multipliers, 36 kb RAMs, shift-registers, etc.

b) The bitstream

• When you synthesize Verilog/VHDL → the tools generate a giant bitstream file (10–500 MB).
• This file is just a huge string of bits that gets loaded into on-chip SRAM at power-up (takes 50–500 ms).
• Every single SRAM cell directly controls one transistor or LUT → the silicon physically rewires itself.

c) Visual analogy

Before bitstream: billions of transistors + switches in “unknown” state
After bitstream: same transistors now form a RISC-V CPU, or 3000 Bitcoin miners, or a 8K video encoder

A common analogy is loading different worlds on the same computer — except that here the hardware itself becomes a different circuit.

3. Real-world examples you can buy today

Summary answer to your two questions

1. How can slow FPGAs do AI/crypto?
   → They are slow in Hz but insanely parallel + custom bit-perfect datapaths. One modern FPGA contains the equivalent of hundreds of old CPUs working in lockstep on the exact problem you care about.

2. How does the silicon physically change?
   → Millions of SRAM-controlled transistors act as programmable wires and logic gates. Loading a new bitstream literally rewires billions of transistors in <1 second.

In 2025, FPGAs are still very much alive in crypto mining, but they’re in a niche sweet spot—not dominating like ASICs for Bitcoin, and not as beginner-friendly as GPUs. They’re the “Goldilocks” option for certain coins: more efficient than GPUs, reprogrammable (unlike ASICs), and profitable on algorithms where ASICs haven’t fully taken over yet.

Why FPGAs Shine in 2025 Mining (Despite “Being Slower”)

Remember our earlier chat: FPGAs trade clock speed for insane custom parallelism + bit-perfect efficiency. In mining:

• A single high-end FPGA (e.g., Xilinx VU33P) can pack thousands of optimized hash cores running at 300–800 MHz.
• Power: Often 100–500W per board, but 5–20x better hashes/watt than GPUs on the right algo.
• Reprogrammable: Switch coins/algos in seconds via bitstreams—no new hardware needed.

This makes them profitable on ASIC-resistant or emerging coins where GPUs flop on efficiency, but ASICs are scarce/expensive.

Top Coins & Algos Mined with FPGAs in 2025

FPGAs dominate where algorithms are memory-hard or frequently tweaked (hard for cheap ASICs). Bitcoin? Forget it—pure ASICs rule SHA-256.

Real 2025 profitability example: A $2,500–$5,000 VU33P setup (e.g., Osprey E300 or SQRL Forest Kitten 33) on Kaspa can net $10–50/day at $0.10/kWh (after power), ROI in 3–12 months depending on coin price. Beats most GPUs, loses to top ASICs on pure BTC.

Hot FPGA Hardware in 2025

No more “one-size-fits-all”—focus on HBM2-equipped boards for memory-heavy algos (600+ GB/s bandwidth crushes GDDR6 GPUs).

Pro tip: Buy with pre-loaded bitstreams + cooling (fans/heatsinks). Tools: TeamRedMiner, BittWare Toolkit for monitoring.

FPGA vs ASIC vs GPU in 2025—Quick Verdict

Bottom line in 2025: FPGAs aren’t “dead”—they’re thriving in the cracks ASICs haven’t sealed. If you’re into Kaspa (huge community buzz), grab a VU33P-based rig. ROI can beat GPUs 5–10x on efficiency, and you can pivot if a coin gets ASIC’d. But electricity < $0.12/kWh is key—otherwise, just buy the coin!

No, FPGAs are not a mainstream choice for AI training in 2025—GPUs (especially NVIDIA H100/B200 series) and custom ASICs (Google TPUs, Amazon Trainium, Groq LPUs) dominate large-scale model training for LLMs like GPT-4o, Llama 3.1, or Grok-4. Training massive models requires brute-force floating-point throughput (PFLOPS-scale), massive parallelism, and easy scaling across thousands of nodes—areas where GPUs excel due to mature ecosystems (CUDA, PyTorch), high-bandwidth memory (HBM3e), and frameworks optimized for them.

That said, FPGAs do play roles in AI training ecosystems, just not as the primary compute engine. Here’s the 2025 reality:

Where FPGAs Shine in AI Training Workflows

FPGAs aren’t replacing GPUs for backpropagation on trillion-parameter models, but they’re critical accelerators in the pipeline:

Real benchmarks (MLPerf Training 2025 submissions):

• NVIDIA Blackwell GPUs: \~10–20x faster than prior gen on LLM training (e.g., GPT-3 scale in hours vs. days).
• No pure-FPGA submissions dominate; hybrids (FPGA NICs + GPUs) show \~15–30% overall speedup via better communication.

FPGA vs. GPU for Training: Head-to-Head (2025)

Companies Using FPGAs in Training (2025)

• Microsoft/Azure: Legacy Brainwave (Stratix 10) evolved into hybrid FPGA NICs for collectives; still in some pipelines but phased toward ASICs.
• AMD/Xilinx: Versal AI Core/Edge in research (e.g., BitNet prototyping); datacenter SmartNICs (Alveo U55C) for training comms.
• Intel/Altera: Agilex 5/7 with AI Tensor Blocks for pre-processing in Gaudi3 hybrids; edge fine-tuning.
• Hyperscalers (Amazon, Google): FPGA NICs (AWS F1 instances aging out; custom now) for bandwidth-bound training.
• Niche/Research: CERN, NASA use Versal for radiation-hard training; startups like EdgeCortix for low-bit fine-tuning.

Bottom Line for 2025

FPGAs are “training adjacent”—essential for efficient datacenters but not the hammer for the nail.
If you’re training LLMs from scratch: Rent GPUs/TPUs.
If you’re building a next-gen AI cluster: Add FPGA SmartNICs for 20–40% more effective FLOPS.
For crypto-style “parallel but custom” workloads? FPGAs crush (as we discussed). For AI training? They’re the clever sidekick, not the hero.

Field-programmable gate array

A field-programmable gate array (FPGA) is a type of configurable integrated circuit that can be repeatedly programmed after manufacturing. FPGAs are a subset of logic devices referred to as programmable logic devices (PLDs). They consist of a grid-connected array of programmable logic blocks that can be configured “in the field” to interconnect with other logic blocks to perform various digital functions. FPGAs are often used in limited (low) quantity production of custom-made products, and in research and development, where the higher cost of individual FPGAs is not as important and where creating and manufacturing a custom circuit would not be feasible. Other applications for FPGAs include the telecommunications, automotive, aerospace, and industrial sectors, which benefit from their flexibility, high signal processing speed, and parallel processing abilities.A FPGA configuration is generally written using a hardware description language (HDL) e.g. VHDL, similar to the ones used for application-specific integrated circuits (ASICs). Circuit diagrams were formerly used to write the configuration.The logic blocks of an FPGA can be configured to perform complex combinational functions, or act as simple logic gates like AND XOR. In most FPGAs, logic blocks also include memory elements, which may be simple flip-flops or more sophisticated blocks of memory.^[1] Many FPGAs can be reprogrammed to implement different logic functions, allowing flexible reconfigurable computing as performed in computer software.FPGAs also have a role in embedded system development due to their capability to start system software development simultaneously with hardware, enable system performance simulations at a very early phase of the development, and allow various system trials and design iterations before finalizing the system architecture.^[2]FPGAs are also commonly used during the development of ASICs to speed up the simulation process.

History of Field-Programmable Gate Arrays

The FPGA industry sprouted from programmable read-only memory (PROM) and programmable logic devices (PLDs). PROMs and PLDs both had the option of being programmed in batches in a factory or in the field (field-programmable).^[3]Altera was founded in 1983 and delivered the industry’s first reprogrammable logic device in 1984 – the EP300 – which featured a quartz window in the package that allowed users to shine an ultra-violet lamp on the die to erase the EPROM cells that held the device configuration.^[4]Xilinx produced the first commercially viable field-programmable gate array in 1985^[3] – the XC2064.^[5] The XC2064 had programmable gates and programmable interconnects between gates, the beginnings of a new technology and market.^[6] The XC2064 had 64 configurable logic blocks (CLBs), with two three-input lookup tables (LUTs).^[7]In 1987, the Naval Surface Warfare Center funded an experiment proposed by Steve Casselman to develop a computer that would implement 600,000 reprogrammable gates. Casselman was successful and a patent related to the system was issued in 1992.^[3]Altera and Xilinx continued unchallenged and quickly grew from 1985 to the mid-1990s when competitors sprouted up, eroding a significant portion of their market share. By 1993, Actel (later Microsemi, now Microchip) was serving about 18 percent of the market.^[6]The 1990s were a period of rapid growth for FPGAs, both in circuit sophistication and the volume of production. In the early 1990s, FPGAs were primarily used in telecommunications and networking. By the end of the decade, FPGAs found their way into consumer, automotive, and industrial applications.^[8]By 2013, Altera (31 percent), Xilinx (36 percent) and Actel (10 percent) together represented approximately 77 percent of the FPGA market.^[9]Companies like Microsoft have started to use FPGAs to accelerate high-performance, computationally intensive systems (like the data centers that operate their Bing search engine), due to the performance per watt advantage FPGAs deliver.^[10] Microsoft began using FPGAs to accelerate Bing in 2014, and in 2018 began deploying FPGAs across other data center workloads for their Azure cloud computing platform.^[11]Since 2019, modern generation of FPGAs have been integrated with other architectures like AI engines to target workloads in artificial intelligence domain.^[12]In the 2020s, the FPGA industry underwent significant consolidation through major acquisitions. In 2020, AMD announced its acquisition of Xilinx, which closed in 2022 for approximately $50 billion, creating a leading high-performance computing provider.^[13][14] Separately, Intel acquired Altera in 2015 but spun it off as a standalone company in 2024 to focus on its core businesses.^[15][16]

Growth

The following timelines indicate progress in different aspects of FPGA design.

Gates

• 1987: 9,000 gates, Xilinx^[6]
• 1992: 600,000, Naval Surface Warfare Department^[3]
• Early 2000s: millions^[8]
• 2013: 50 million, Xilinx^[17]

Market size

• 1985: First commercial FPGA : Xilinx XC2064^[5][6]
• 1987: $14 million^[6]
• c. 1993: >$385 million^[6]
• 2005: $1.9 billion^[18]
• 2010 estimates: $2.75 billion^[18]
• 2013: $5.4 billion^[19]
• 2020 estimate: $9.8 billion^[19]
• 2030 estimate: $23.34 billion^[20]

Design starts

A design start is a new custom design for implementation on an FPGA.

Design

Contemporary FPGAs have ample logic gates and RAM blocks to implement complex digital computations. FPGAs can be used to implement any logical function that an ASIC can perform. The ability to update the functionality after shipping, partial re-configuration of a portion of the design^[21] and the low non-recurring engineering costs relative to an ASIC design (notwithstanding the generally higher unit cost), offer advantages for many applications.^[1]As FPGA designs employ very fast I/O rates and bidirectional data buses, it becomes a challenge to verify correct timing of valid data within setup time and hold time.^[22] Floor planning helps resource allocation within FPGAs to meet these timing constraints.Some FPGAs have analog features in addition to digital functions. The most common analog feature is a programmable slew rate on each output pin. This allows the user to set low rates on lightly loaded pins that would otherwise ring or couple unacceptably, and to set higher rates on heavily loaded high-speed channels that would otherwise run too slowly.^[23][24] Also common are quartz-crystal oscillator driver circuitry, on-chip RC oscillators, and phase-locked loops with embedded voltage-controlled oscillators used for clock generation and management as well as for high-speed serializer-deserializer (SERDES) transmit clocks and receiver clock recovery. Fairly common are differential comparators on input pins designed to be connected to differential signaling channels. A few mixed signal FPGAs have integrated peripheral analog-to-digital converters (ADCs) and digital-to-analog converters (DACs) with analog signal conditioning blocks, allowing them to operate as a system on a chip (SoC).^[25] Such devices blur the line between an FPGA, which carries digital ones and zeros on its internal programmable interconnect fabric, and field-programmable analog array (FPAA), which carries analog values on its internal programmable interconnect fabric.

Logic blocks

The most common FPGA architecture consists of an array of logic blocks called configurable logic blocks (CLBs) or logic array blocks (LABs) (depending on vendor), I/O pads, and routing channels.^[1] Generally, all the routing channels have the same width (number of signals). Multiple I/O pads may fit into the height of one row or the width of one column in the array.”An application circuit must be mapped into an FPGA with adequate resources. While the number of logic blocks and I/Os required is easily determined from the design, the number of routing channels needed may vary considerably even among designs with the same amount of logic. For example, a crossbar switch requires much more routing than a systolic array with the same gate count. Since unused routing channels increase the cost (and decrease the performance) of the FPGA without providing any benefit, FPGA manufacturers try to provide just enough channels so that most designs that will fit in terms of lookup tables (LUTs) and I/Os can be routed. This is determined by estimates such as those derived from Rent’s rule or by experiments with existing designs.”^[26]In general, a logic block consists of a few logical cells. A typical cell in contemporary FPGAs consists of a 6-input LUT (configurable as two 5-input LUTs), a full adder (FA) and a D-type flip-flop. In normal mode those are combined into a 6-input LUT through the first multiplexer (mux). In arithmetic mode, their outputs are fed to the adder. The selection of mode is programmed into the second mux. The output can be either synchronous or asynchronous, depending on the programming of the third mux. In practice, the entire adder or parts of it are stored as functions into the LUTs in order to save space.^[27][28]

Hard blocks

Modern FPGA families expand upon the above capabilities to include higher-level functionality fixed in silicon. Having these common functions embedded in the circuit reduces the area required and gives those functions increased performance compared to building them from logical primitives. Examples of these include multipliers, generic DSP blocks, embedded processors, high-speed I/O logic and embedded memories.Higher-end FPGAs can contain high-speed multi-gigabit transceivers and hard IP cores such as processor cores, Ethernet medium access control units, PCI or PCI Express controllers, and external memory controllers. These cores exist alongside the programmable fabric, but they are built out of transistors instead of LUTs so they have ASIC-level performance and power consumption without consuming a significant amount of fabric resources, leaving more of the fabric free for the application-specific logic. The multi-gigabit transceivers also contain high-performance signal conditioning circuitry along with high-speed serializers and deserializers, components that cannot be built out of LUTs. Higher-level physical layer (PHY) functionality such as line coding may or may not be implemented alongside the serializers and deserializers in hard logic, depending on the FPGA.

Soft core

An alternate approach to using hard macro processors is to make use of soft processor IP cores that are implemented within the FPGA logic. Nios II, MicroBlaze and Mico32 are examples of popular softcore processors. Many modern FPGAs are programmed at run time , which has led to the idea of reconfigurable computing or reconfigurable systems – CPUs that reconfigure themselves to suit the task at hand. Additionally, new non-FPGA architectures are beginning to emerge. Software-configurable microprocessors such as the Stretch S5000 adopt a hybrid approach by providing an array of processor cores and FPGA-like programmable cores on the same chip.

Integration

In 2012 the coarse-grained architectural approach was taken a step further by combining the logic blocks and interconnects of traditional FPGAs with embedded microprocessors and related peripherals to form a complete system on a programmable chip. Examples of such hybrid technologies can be found in the Xilinx Zynq-7000 all programmable SoC,^[29] which includes a 1.0 GHz dual-core ARM Cortex-A9 MPCore processor embedded within the FPGA’s logic fabric,^[30] or in the Altera Arria V FPGA, which includes an 800 MHz dual-core ARM Cortex-A9 MPCore. The Atmel FPSLIC is another such device, which uses an AVR processor in combination with Atmel’s programmable logic architecture. The Microsemi SmartFusion devices incorporate an ARM Cortex-M3 hard processor core (with up to 512 kB of flash and 64 kB of RAM) and analog peripherals such as a multi-channel analog-to-digital converters and digital-to-analog converters in their flash memory-based FPGA fabric.More recent examples include the AMD Versal Adaptive SoCs (introduced 2019, with Gen 2 in 2024), which integrate up to quad-core Arm Cortex-A72 or A78AE processors running at up to 2.4 GHz, AI Engines for machine learning acceleration, and programmable logic fabric for heterogeneous computing.^[31] Similarly, Altera’s Agilex 5 SoC FPGAs (updated 2025) feature Arm Cortex-A55 and A78AE cores for edge AI and high-performance applications, with up to 2.5x density improvements for 5G/6G and video processing.^[32]

Clocking

Most of the logic inside of an FPGA is synchronous circuitry that requires a clock signal. FPGAs contain dedicated global and regional routing networks for clock and reset, typically implemented as an H tree, so they can be delivered with minimal skew. FPGAs may contain analog phase-locked loop or delay-locked loop components to synthesize new clock frequencies and manage jitter. Complex designs can use multiple clocks with different frequency and phase relationships, each forming separate clock domains. These clock signals can be generated locally by an oscillator or they can be recovered from a data stream. Care must be taken when building clock domain crossing circuitry to avoid metastability. Some FPGAs contain dual port RAM blocks that are capable of working with different clocks, aiding in the construction of building FIFOs and dual port buffers that bridge clock domains.

3D architectures

To shrink the size and power consumption of FPGAs, vendors such as Tabula and Xilinx have introduced 3D or stacked architectures.^[33][34] Following the introduction of its 28 nm 7-series FPGAs, Xilinx said that several of the highest-density parts in those FPGA product lines will be constructed using multiple dies in one package, employing technology developed for 3D construction and stacked-die assemblies.Xilinx’s approach stacks several (three or four) active FPGA dies side by side on a silicon interposer – a single piece of silicon that carries passive interconnect.^[34][35] The multi-die construction also allows different parts of the FPGA to be created with different process technologies, as the process requirements are different between the FPGA fabric itself and the very high speed 28 Gbit/s serial transceivers. An FPGA built in this way is called a heterogeneous FPGA.^[36]Altera’s heterogeneous approach involves using a single monolithic FPGA die and connecting other dies and technologies to the FPGA using Intel’s embedded multi_die interconnect bridge (EMIB) technology.^[37] Modern implementations continue this trend, with AMD Versal Premium Gen 2 (2024) using 2.5D interposers for high-bandwidth memory integration and Altera Agilex series employing EMIB for multi-die connectivity in AI and networking applications.^[38][39]

Programming

To define the behavior of the FPGA, the user provides a design in a hardware description language (HDL) or as a schematic design. The HDL form is more suited to work with large structures because it’s possible to specify high-level functional behavior rather than drawing every piece by hand. However, schematic entry can allow for easier visualization of a design and its component modules.Using an electronic design automation tool, a technology-mapped netlist is generated. The netlist can then be fit to the actual FPGA architecture using a process called place and route, usually performed by the FPGA company’s proprietary place-and-route software. The user will validate the results using timing analysis, simulation, and other verification and validation techniques. Once the design and validation process is complete, the binary file generated, typically using the FPGA vendor’s proprietary software, is used to (re-)configure the FPGA. This file is transferred to the FPGA via a serial interface (JTAG) or to an external memory device such as an EEPROM.The most common HDLs are VHDL and SystemVerilog (an extension of Verilog).^[40] National Instruments’ LabVIEW graphical programming language (sometimes referred to as G) has an FPGA add-in module available to target and program FPGA hardware. SystemVerilog extends Verilog with enhanced features for design and verification, maintaining a C-like syntax unlike VHDL.To simplify the design of complex systems in FPGAs, there exist libraries of predefined complex functions and circuits that have been tested and optimized to speed up the design process. These predefined circuits are commonly called intellectual property (IP) cores, and are available from FPGA vendors and third-party IP suppliers. They are rarely free, and typically released under proprietary licenses. Other predefined circuits are available from developer communities such as OpenCores (typically released under free and open source licenses such as the GPL, BSD or similar license). Such designs are known as open-source hardware.In a typical design flow, an FPGA application developer will simulate the design at multiple stages throughout the design process. Initially the RTL description in VHDL or SystemVerilog is simulated by creating test benches to simulate the system and observe results. Then, after the synthesis engine has mapped the design to a netlist, the netlist is translated to a gate-level description where simulation is repeated to confirm the synthesis proceeded without errors. Finally, the design is laid out in the FPGA at which point propagation delay values can be back-annotated onto the netlist, and the simulation can be run again with these values.More recently, OpenCL (Open Computing Language) is being used by programmers to take advantage of the performance and power efficiencies that FPGAs provide. OpenCL allows programmers to develop code in the C programming language.^[41] OpenCL is one of several high-level synthesis approaches; others include tools supporting C/C++ and Python for algorithmic descriptions translated to HDL. For further information, see high-level synthesis and C to HDL.Most FPGAs rely on an SRAM-based approach to be programmed. These FPGAs are in-system programmable and re-programmable, but require external boot devices. For example, flash memory or EEPROM devices may load contents into internal SRAM that controls routing and logic. The SRAM approach is based on CMOS.Rarer alternatives to the SRAM approach include:

• Fuse: one-time programmable. Bipolar. Obsolete.
• Antifuse: one-time programmable. CMOS. Examples: Actel SX and Axcelerator families; Quicklogic Eclipse II family.^[42]
• PROM: programmable read-only memory technology. One-time programmable because of plastic packaging. Obsolete.
• EPROM: erasable programmable read-only memory technology. One-time programmable but with window, can be erased with ultraviolet (UV) light. CMOS. Obsolete.
• EEPROM: electrically erasable programmable read-only memory technology. Can be erased, even in plastic packages. Some but not all EEPROM devices can be in-system programmed. CMOS.
• Flash: flash-erase EPROM technology. Can be erased, even in plastic packages. Some but not all flash devices can be in-system programmed. Usually, a flash cell is smaller than an equivalent EEPROM cell and is, therefore, less expensive to manufacture. CMOS. Example: Actel ProASIC family.^[42]

Manufacturers

In 2016, long-time industry rivals Xilinx (now part of AMD) and Altera (now operationally independent with majority ownership by Silver Lake) were the FPGA market leaders.^[43] At that time, they controlled nearly 90 percent of the market. As of 2025, AMD (Xilinx) and Altera remain the leading FPGA manufacturers, with AMD holding about 55% market share and Altera approximately 30%.^[44]Both Xilinx and Altera provide proprietary electronic design automation software for Windows and Linux (ISE/Vivado and Quartus) which enables engineers to design, analyze, simulate, and synthesize (compile) their designs.^[45][46]In March 2010, Tabula announced their FPGA technology that uses time-multiplexed logic and interconnect that claims potential cost savings for high-density applications.^[47] On March 24, 2015, Tabula officially shut down.^[48]On June 1, 2015, Intel announced it would acquire Altera for approximately US$16.7 billion and completed the acquisition on December 30, 2015.^[15] In February 2024, Intel launched Altera as a standalone FPGA company.^[16] In 2025, Intel sold a 51% stake in Altera to Silver Lake for $8.75 billion, making Altera operationally independent with Intel holding a 49% minority stake.^[49]On October 27, 2020, AMD announced it would acquire Xilinx^[13] and completed the acquisition valued at about US$50 billion in February 2022.^[14]Other manufacturers include:

• Achronix, manufacturing high-performance SRAM-based FPGAs optimized for bandwidth-intensive applications such as AI/ML and data centers^[50]
• Cologne Chip, German government-backed designer and producer of FPGAs^[51]
• Efinix offers small to medium-sized FPGAs. They combine logic and routing interconnects into a configurable XLR cell.
• GOWIN Semiconductors, manufacturing small and medium-sized SRAM and flash-based FPGAs. They also offer pin-compatible replacements for a few Xilinx, Altera and Lattice products.
• Lattice Semiconductor manufactures low-power SRAM-based FPGAs featuring integrated configuration flash, instant-on and live reconfiguration
• SiliconBlue Technologies provides extremely low-power SRAM-based FPGAs with optional integrated nonvolatile configuration memory; acquired by Lattice in 2011
• Microchip:
• Microsemi (previously Actel), producing antifuse, flash-based, mixed-signal FPGAs; acquired by Microchip in 2018
• Atmel, a second source of some Altera-compatible devices; also FPSLIC mentioned above;^[52] acquired by Microchip in 2016
• QuickLogic manufactures ultra-low-power sensor hubs, extremely-low-powered, low-density SRAM-based FPGAs, with display bridges MIPI and RGB inputs; MIPI, RGB and LVDS outputs.^[53]

Applications

An FPGA can be used to solve any problem which is computable. FPGAs can be used to implement a soft microprocessor, such as the Xilinx MicroBlaze or Altera Nios II. But their advantage lies in that they are significantly faster for some applications because of their parallel nature and optimality in terms of the number of gates used for certain processes.FPGAs were originally introduced as competitors to CPLDs to implement glue logic for printed circuit boards. As their size, capabilities, and speed increased, FPGAs took over additional functions to the point where some are now marketed as full systems on chips (SoCs). Particularly with the introduction of dedicated multipliers into FPGA architectures in the late 1990s, applications that had traditionally been the sole reserve of digital signal processors (DSPs) began to use FPGAs instead.^[54][55]The evolution of FPGAs has motivated an increase in the use of these devices, whose architecture allows the development of hardware solutions optimized for complex tasks, such as 3D MRI image segmentation, 3D discrete wavelet transform, tomographic image reconstruction, or PET/MRI systems.^[56][57] The developed solutions can perform intensive computation tasks with parallel processing, are dynamically reprogrammable, and have a low cost, all while meeting the hard real-time requirements associated with medical imaging.Another trend in the use of FPGAs is hardware acceleration, where one can use the FPGA to accelerate certain parts of an algorithm and share part of the computation between the FPGA and a general-purpose processor. The search engine Bing is noted for adopting FPGA acceleration for its search algorithm in 2014.^[58] FPGAs continue to see increased use as AI accelerators, including Microsoft’s Project Catapult^[11] and for accelerating artificial neural networks for machine learning applications, particularly in edge computing and real-time inference as of 2025.^[59]Originally, FPGAs were reserved for specific vertical applications where the volume of production is small. For these low-volume applications, the premium that companies pay in hardware cost per unit for a programmable chip is more affordable than the development resources spent on creating an ASIC. Often a custom-made chip would be cheaper if made in larger quantities, but FPGAs may be chosen to quickly bring a product to market. By 2017, new cost and performance dynamics broadened the range of viable applications.Other uses for FPGAs include:

• Space (with radiation hardening^[60])
• Hardware security modules^[61]
• High-speed financial transactions^[62][63]
• Retrocomputing (e.g. the MARS and MiSTer FPGA projects)^[64]
• Large scale integrated digital differential analyzers, a form of an analog computer based on digital computing elements^[65]
• Automotive (e.g., advanced driver-assistance systems (ADAS) and autonomous driving)^[66]

Usage by United States military

FPGAs play a crucial role in modern military communications, particularly in software-defined radios (SDRs) and systems such as the Multifunctional Information Distribution System (MIDS) Joint Tactical Radio System (JTRS), as well as devices from companies such as Thales and L3Harris Technologies (successor to Harris Corporation). Their flexibility and programmability make them ideal for military communications, offering customizable and secure signal processing. In MIDS JTRS, used by the US military, FPGAs provide adaptability and real-time processing, crucial for meeting various communication standards and encryption methods.^[67]

Security

Concerning hardware security, FPGAs have both advantages and disadvantages as compared to ASICs or secure microprocessors. FPGAs’ flexibility makes malicious modifications during fabrication a lower risk.^[68] Previously, for many FPGAs, the design bitstream was exposed while the FPGA loads it from external memory, typically during powerup. All major FPGA vendors now offer a spectrum of security solutions to designers such as bitstream encryption and authentication. For example, Altera and Xilinx offer AES encryption (up to 256-bit) for bitstreams stored in an external flash memory. Physical unclonable functions (PUFs) are integrated circuits that have their own unique signatures and can be used to secure FPGAs while taking up very little hardware space.^[69]FPGAs that store their configuration internally in nonvolatile flash memory, such as Microsemi’s ProAsic 3 or Lattice’s XP2 programmable devices, do not expose the bitstream and do not need encryption. Customers wanting a higher guarantee of tamper resistance can use write-once, antifuse FPGAs from vendors such as Microsemi.With its Stratix 10 FPGAs and SoCs, Altera introduced a Secure Device Manager and physical unclonable functions to provide high levels of protection against physical attacks.^[70][71]In 2012 researchers Sergei Skorobogatov and Christopher Woods demonstrated that some FPGAs can be vulnerable to hostile intent. They discovered a critical backdoor vulnerability had been manufactured in silicon as part of the Actel/Microsemi ProAsic 3 making it vulnerable on many levels such as reprogramming crypto and access keys, accessing unencrypted bitstream, modifying low-level silicon features, and extracting configuration data.^[72]In 2020 a critical vulnerability (named Starbleed) was discovered in all Xilinx 7-series and Virtex-6 FPGAs that rendered bitstream encryption useless. There is no workaround. Xilinx did not produce a hardware revision. Ultrascale and later devices, already on the market at the time, were not affected.^[73]Modern FPGAs, such as Intel’s Agilex series (as of 2024), continue to enhance security with advanced PUF implementations and Secure Device Manager features for improved protection against physical and supply chain attacks.^[74][75]

Similar technologies

Historically, FPGAs have been slower, less energy efficient and generally achieved less functionality than their fixed ASIC counterparts. A study from 2006 showed that designs implemented on FPGAs need on average 40 times as much area, draw 12 times as much dynamic power, and run at one third the speed of corresponding ASIC implementations.^[76]Advantages of FPGAs include the ability to reprogram equipment in the field to fix bugs or make other improvements. Some FPGAs have the capability of partial re-configuration that lets one portion of the device be re-programmed while other portions continue running.^[77][78] Other advantages may include shorter time to market and lower non-recurring engineering costs. Vendors can also take a middle road via FPGA prototyping: developing their prototype hardware on FPGAs, but manufacturing their final version as an ASIC after the design has been committed. This is often also the case with new processor designs.^[79]The primary differences between complex programmable logic devices (CPLDs) and FPGAs are architectural. A CPLD has a comparatively restrictive structure consisting of one or more programmable sum-of-products logic arrays feeding a relatively small number of clocked registers. As a result, CPLDs are less flexible but have the advantage of more predictable timing delays and a higher logic-to-interconnect ratio. FPGA architectures, on the other hand, are dominated by interconnect. This makes them far more flexible (in terms of the range of designs that are practical for implementation on them) but also far more complex to design for, or at least requiring more complex electronic design automation (EDA) software. In practice, the distinction between FPGAs and CPLDs is often one of size as FPGAs are usually much larger in terms of resources than CPLDs. Typically only FPGAs contain more complex embedded functions such as adders, multipliers, memory, and serializer/deserializers. Another common distinction is that CPLDs contain embedded flash memory to store their configuration while FPGAs usually require external non-volatile memory (but not always). When a design requires simple instant-on (logic is already configured at power-up) CPLDs are generally preferred. For most other applications FPGAs are generally preferred. Sometimes both CPLDs and FPGAs are used in a single system design. In those designs, CPLDs generally perform glue logic functions and are responsible for “booting” the FPGA as well as controlling reset and boot sequence of the complete circuit board. Therefore, depending on the application it may be judicious to use both FPGAs and CPLDs in a single design.^[80]

References

1. “FPGA Architecture for the Challenge”. toronto.edu. University of Toronto.
2. Simpson, P. A. (2015). FPGA Design, Best Practices for Team Based Reuse, 2nd edition. Switzerland: Springer International Publishing AG. p. 16. ISBN 978-3-319-17924-7.
3. “History of FPGAs”. Archived from the original on April 12, 2007. Retrieved 2013-07-11.
4. Ron Wilson (21 April 2015). “In the Beginning”. altera.com. Archived from the original on 2015-04-21.
5. “XCELL issue 32” (PDF). Xilinx. Archived (PDF) from the original on 2011-01-07.
6. Funding Universe. “Xilinx, Inc.” Retrieved January 15, 2009.
7. Clive Maxfield, Programmable Logic DesignLine, “Xilinx unveil revolutionary 65nm FPGA architecture: the Virtex-5 family Archived 2009-12-25 at the Wayback Machine. May 15, 2006. Retrieved February 5, 2009.
8. Maxfield, Clive (2004). The Design Warrior’s Guide to FPGAs: Devices, Tools and Flows. Elsevier. p. 4. ISBN 978-0-7506-7604-5.
9. “Top FPGA Companies For 2013”. sourcetech411.com. 2013-04-28. Archived from the original on 2015-07-09. Retrieved 2015-07-08.
10. “Microsoft Supercharges Bing Search With Programmable Chips”. WIRED. 16 June 2014.
11. “Project Catapult”. Microsoft Research. July 2018.
12. Gaide, Brian; Gaitonde, Dinesh; Ravishankar, Chirag; Bauer, Trevor (2019-02-20). “Xilinx Adaptive Compute Acceleration Platform: Versal TM Architecture”. ACM/SIGDA International Symposium on Field-Programmable Gate Arrays. ACM: 84–93. doi:10.1145/3289602.3293906. ISBN 978-1-4503-6137-8.
13. “AMD to Acquire Xilinx, Creating the Industry’s High Performance Computing Leader”. October 2020.
14. “AMD closes record chip industry deal with estimated $50 billion purchase of Xilinx”. Reuters. February 2022.
15. “Intel to buy Altera for $16.7 billion in its biggest deal ever”. Reuters. June 2015.
16. “Intel Launches Altera, Its New Standalone FPGA Company”. Intel (Press release). Retrieved 2024-02-29.
17. Maxfield, Max. “Xilinx UltraScale FPGA Offers 50 Million Equivalent ASIC Gates”. www.eetimes.com. EE Times.
18. Dylan McGrath, EE Times , “FPGA Market to Pass $2.7 Billion by ‘10, In-Stat Says”. May 24, 2006. Retrieved February 5, 2009.
19. “Global FPGA Market Analysis And Segment Forecasts To 2020 – FPGA Industry, Outlook, Size, Application, Product, Share, Growth Prospects, Key Opportunities, Dynamics, Trends, Analysis, FPGA Report – Grand View Research Inc”. grandviewresearch.com.
20. “Field Programmable Gate Array Market To Reach $23.34Bn By 2030”. www.grandviewresearch.com. Retrieved 2024-04-25.
21. Wisniewski, Remigiusz (2009). Synthesis of compositional microprogram control units for programmable devices. Zielona Góra: University of Zielona Góra. p. 153. ISBN 978-83-7481-293-1.
22. Oklobdzija, Vojin G. (2017). Digital Design and Fabrication. CRC Press. ISBN 9780849386046.
23. “FPGA Signal Integrity tutorial”. altium.com. Archived from the original on 2016-03-07. Retrieved 2010-06-15.
24. NASA: FPGA drive strength Archived 2010-12-05 at the Wayback Machine
25. Mike Thompson (2007-07-02). “Mixed-signal FPGAs provide GREEN POWER”. Design & Reuse.
26. M.b, Swami; V.p, Pawar (2014-07-31). “VLSI DESIGN: A NEW APPROACH”. Journal of Intelligence Systems. 4 (1): 60–63. ISSN 2229-7057.
27. LUT6
28. Intel
29. “Xilinx Inc, Form 8-K, Current Report, Filing Date Oct 19, 2011”. secdatabase.com. Retrieved May 6, 2018.
30. “Xilinx Inc, Form 10-K, Annual Report, Filing Date May 31, 2011”. secdatabase.com. Retrieved May 6, 2018.
31. versal
32. overview
33. Dean Takahashi, VentureBeat. “Intel connection helped chip startup Tabula raise $108M.” May 2, 2011. Retrieved May 13, 2011.
34. Lawrence Latif, The Inquirer. “FPGA manufacturer claims to beat Moore’s Law.” October 27, 2010. Retrieved May 12, 2011.
35. EDN Europe. “Xilinx adopts stacked-die 3D packaging Archived 2011-02-19 at the Wayback Machine.” November 1, 2010. Retrieved May 12, 2011.
36. Saban, Kirk (December 11, 2012). “Xilinx Stacked Silicon Interconnect Technology Delivers Breakthrough FPGA Capacity, Bandwidth, and Power Efficiency” (PDF). xilinx.com. Archived (PDF) from the original on 2010-11-05. Retrieved 2018-11-30.
37. “Intel Custom Foundry EMIB”. Intel. Archived from the original on 2015-07-13. Retrieved 2015-07-13.
38. AMD
39. overview
40. “Battle Over the FPGA: VHDL vs Verilog! Who is the True Champ?”. digilentinc.com. Archived from the original on 2020-12-26. Retrieved 2020-12-16.
41. “Why use OpenCL on FPGAs?”. StreamComputing. 2014-09-16. Archived from the original on 2017-01-01. Retrieved 2015-07-17.
42. “All about FPGAs”. 21 March 2006.
43. Dillien, Paul (March 6, 2017). “And the Winner of Best FPGA of 2016 is…” EETimes. Archived from the original on January 5, 2019. Retrieved September 7, 2017.
44. 139 fpga companies
45. “Xilinx ISE Design Suite”. www.xilinx.com. Retrieved 2018-12-01.
46. “FPGA Design Software - Intel Quartus Prime”. Intel. Retrieved 2018-12-01.
47. “Tabula’s Time Machine — Micro Processor Report” (PDF). Archived from the original (PDF) on 2011-04-10.
48. Tabula to shut down; 120 jobs lost at fabless chip company Silicon Valley Business Journal
49. Altera
50. “Achronix to Use Intel’s 22nm Manufacturing”. Intel Newsroom (Press release). 2010-11-01. Archived from the original on 2015-09-30. Retrieved 2018-12-01.
51. “About the company – Cologne Chip”. Retrieved 2024-02-27.
52. “Top FPGA Companies For 2013”. SourceTech411. 2013-04-28. Archived from the original on 2018-08-24. Retrieved 2018-12-01.
53. “QuickLogic — Customizable Semiconductor Solutions for Mobile Devices”. www.quicklogic.com. QuickLogic Corporation. Retrieved 2018-10-07.
54. “Publications and Presentations”. bdti.com. Archived from the original on 2010-08-21. Retrieved 2018-11-02.
55. LaPedus, Mark (5 February 2007). “Xilinx aims 65-nm FPGAs at DSP applications”. EETimes.
56. Alcaín, Eduardo; Fernández, Pedro R.; Nieto, Rubén; Montemayor, Antonio S.; Vilas, Jaime; Galiana-Bordera, Adrian; Martinez-Girones, Pedro Miguel; Prieto-de-la-Lastra, Carmen; Rodriguez-Vila, Borja; Bonet, Marina; Rodriguez-Sanchez, Cristina (2021-12-15). “Hardware Architectures for Real-Time Medical Imaging”. Electronics. 10 (24): 3118. doi:10.3390/electronics10243118. ISSN 2079-9292.
57. Nagornov, Nikolay N.; Lyakhov, Pavel A.; Valueva, Maria V.; Bergerman, Maxim V. (2022). “RNS-Based FPGA Accelerators for High-Quality 3D Medical Image Wavelet Processing Using Scaled Filter Coefficients”. IEEE Access. 10 : 19215–19231. Bibcode:2022IEEEA..1019215N. doi:10.1109/ACCESS.2022.3151361. ISSN 2169-3536. S2CID 246895876.
58. Morgan, Timothy Pricket (2014-09-03). “How Microsoft Is Using FPGAs To Speed Up Bing Search”. Enterprise Tech. Retrieved 2018-09-18.
59. fpga and machine learning unlocking the future of ai hardware
60. “FPGA development devices for radiation-hardened space applications introduced by Microsemi”. www.militaryaerospace.com. 2016-06-03. Retrieved 2018-11-02.
61. “CrypTech: Building Transparency into Cryptography t” (PDF). Archived (PDF) from the original on 2016-08-07.
62. Mann, Tobias (2023-03-08). “While Intel XPUs are delayed, here’s some more FPGAs to tide you over”. The Register.
63. Leber, Christian; Geib, Benjamin; Litz, Heiner (September 2011). High Frequency Trading Acceleration Using FPGAs. International Conference on Field Programmable Logic and Applications. IEEE. doi:10.1109/FPL.2011.64.
64. “The DIY MiSTer Handheld”. 16 December 2024.
65. DDA on FPGA - A modern Analog Computer
66. FPGAs Are Essential Building Blocks for Next Gen Automotive Designs
67. mids jtrs
68. Huffmire, Ted; Brotherton, Brett; Sherwood, Timothy; Kastner, Ryan; Levin, Timothy; Nguyen, Thuy D.; Irvine, Cynthia (2008). “Managing Security in FPGA-Based Embedded Systems”. IEEE Design & Test of Computers. 25 (6): 590–598. doi:10.1109/MDT.2008.166. hdl:10945/7159. S2CID 115840.
69. Babaei, Armin; Schiele, Gregor; Zohner, Michael (2022-07-26). “Reconfigurable Security Architecture (RESA) Based on PUF for FPGA-Based IoT Devices”. Sensors. 22 (15): 5577. Bibcode:2022Senso..22.5577B. doi:10.3390/s22155577. ISSN 1424-8220. PMC 9331300. PMID 35898079.
70. “EETimes on PUF: Security features for non-security experts – Intrinsic ID”. Intrinsic ID. 2015-06-09. Retrieved 2015-07-12.
71. Intel
72. Skorobogatov, Sergei; Woods, Christopher (2012). “Breakthrough Silicon Scanning Discovers Backdoor in Military Chip”. Cryptographic Hardware and Embedded Systems – CHES 2012. Lecture Notes in Computer Science. Vol. 7428. pp. 23–40. doi:10.1007/978-3-642-33027-8_2. ISBN 978-3-642-33026-1.
73. ender
74. Intel
75. to secure reprogrammable chips the us must address supply chain risks
76. Kuon, Ian; Rose, Jonathan (2006). “Measuring the gap between FPGAs and ASICs” (PDF). Proceedings of the international symposium on Field programmable gate arrays – FPGA‘06. New York, NY: ACM. pp. 21–30. doi:10.1145/1117201.1117205. ISBN 1-59593-292-5. Archived from the original (PDF) on 2010-06-22. Retrieved 2017-10-25.
77. “AN 818: Static Update Partial Reconfiguration Tutorial: for Intel Stratix 10 GX FPGA Development Board”. www.intel.com. Retrieved 2018-12-01.
78. “Can FPGAs dynamically modify their logic?”. Electrical Engineering Stack Exchange. Retrieved 2018-12-01.
79. Cutress, Ian (August 27, 2019). “Xilinx Announces World Largest FPGA: Virtex Ultrascale+ VU19P with 9m Cells”. AnandTech. Archived from the original on August 27, 2019.
80. “CPLD vs FPGA: Differences between them and which one to use? – Numato Lab Help Center”. numato.com. 2017-11-29.

Part index

The scientific map, the equations, and the bibliographic spine for this part of the Knowledge Base are collected in the part indexes:

• General · Engineering · Computer science · Playbooks
• Indexes · Glossary · SUMMARY

Wikipedia snapshots in the chapter card offer offline orientation; the part indexes carry the full citation trails.