Advanced Architectural Design Principles for Central Processing Unit and Network Interface Integration

 

The Evolution of Host-Centric Computing and Network Convergence

The exponential growth of global data center traffic, propelled by the mass scale of distributed cloud applications, microservices architectures, and large-scale artificial intelligence workloads, has fundamentally exposed the inherent limitations of traditional host-centric computing architectures. Historically, the Central Processing Unit (CPU) operated as the undisputed master of the computing environment, with network interface cards (NICs) acting as simple, peripheral input/output (I/O) conduits. In this legacy paradigm, the network interface merely converted electrical or optical signals into digital bitstreams, leaving the entirety of protocol processing, data movement, and connection management to the host CPU.1

However, as network bandwidths have rapidly scaled from 10 Gbps to 100 Gbps, 200 Gbps, and beyond, the general-purpose CPU has become the primary bottleneck within the modern server node.2 The sheer volume of incoming packets arriving at nanosecond intervals forces the host processor to dedicate a disproportionate amount of its execution cycles to basic infrastructure tasks—such as packet parsing, checksum verification, interrupt handling, and memory copying—leaving insufficient compute resources available for the actual tenant applications or revenue-generating high-level workloads.3 In addition, the migration of workloads to the cloud has introduced severe latency challenges arising from the expanded distances between cloud-based applications and endpoint devices. Enterprise cloud architects must navigate the "five C's of latency"—connection, closeness, capacity, contention, and consistency—which complicate the delivery of real-time services.5 Every routing hop introduces potential latency and performance variability, prompting the industry to seek solutions that minimize network hops and process requests at the closest possible architectural point.5

To overcome these physical and computational constraints, the industry is undergoing a structural paradigm shift toward architectural homogenization and hardware-software co-design.2 This evolution involves offloading critical infrastructure logic from the CPU directly to the network module, transforming the NIC from a passive peripheral into an intelligent co-processor.2 This transition demands a rigorous re-architecting of both the CPU's internal microarchitecture and the sophisticated interconnects that bridge the compute and network domains. The architectural roadmap dictates a move away from legacy, non-cache-coherent Peripheral Component Interconnect Express (PCIe) buses and software-managed protocol stacks, toward Compute Express Link (CXL) coherent memory fabrics, highly programmable Data Processing Units (DPUs), and hardware-accelerated Transport Control Protocol (TCP) offload engines.7 This report details the exhaustive architectural principles, memory hierarchies, interconnect protocols, and physical security mechanisms required to design state-of-the-art CPU and internet network modules capable of sustaining next-generation data rates.

Fundamental Central Processing Unit Microarchitecture

Instruction Set Architecture versus Microarchitecture Implementation

The Central Processing Unit is traditionally conceptualized through the foundational lens of the von Neumann architecture, comprising the Control Unit, the Arithmetic Logic Unit (ALU), and defined interfaces to hierarchical memory and I/O devices.9 However, in the context of modern, high-performance silicon design, it is absolutely critical to delineate the Instruction Set Architecture (ISA) from the underlying microarchitecture.10

The ISA defines the rigid contractual boundary between the hardware and the software stack. It establishes exactly what instructions the CPU is capable of executing, effectively defining the operational vocabulary of the processor.10 Conversely, the microarchitecture dictates the internal physical implementation of that vocabulary, including the design of execution pipelines, branch predictors, out-of-order execution units, and the complex physical datapath.10 Therefore, multiple processors from different manufacturers or different generations can share the exact same ISA while possessing wildly different internal microarchitectures.10

Modern central processors devote massive amounts of semiconductor die area to instruction-level parallelism and deep, multi-tiered cache hierarchies to maximize single-thread and multi-thread performance.1 The datapath meticulously coordinates the movement of operands from processor registers to the ALU, where arithmetic, logical, and controlling operations are executed, before storing the computed results back into registers or dispatching them down into the memory hierarchy.1 As network speeds increase, the efficiency of this specific datapath is severely tested. A deeply pipelined microarchitecture can suffer massive performance penalties during context switches or mispredicted branches—both of which are common occurrences in legacy software-based network interrupt handling, where the CPU is forced to frequently halt its primary execution thread to process incoming packet headers.

Modern ISA Extensions for Network Packet Processing

To accelerate high-throughput packet processing without offloading the entirety of the logic to dedicated Application-Specific Integrated Circuits (ASICs), modern ISAs have introduced advanced vector processing extensions. These hardware extensions allow the CPU to process multiple packet headers or payloads simultaneously using Single Instruction, Multiple Data (SIMD) programming paradigms, significantly reducing the instruction fetch overhead.13 Because these extensions exist as part of the core instruction stream, they offer exceptionally low-latency execution, completely bypassing the overhead associated with forming request packets and batching them to an external hardware accelerator over a system bus.13

The architectural approaches to vector processing, however, diverge significantly between the dominant ISAs, particularly between ARM's Scalable Vector Extension (SVE) and the open-source RISC-V Vector Extension (RVV).13 ARM SVE, deeply inspired by classical supercomputing architectures like the Cray-1, introduced variable-length vectors that adapt dynamically to the specific requirements of the workload.14 This dynamic adaptability allows the hardware to scale seamlessly across various network application domains without requiring software recompilation for different vector register widths.14

In contrast, the RISC-V Vector extension operates with a different philosophical approach. While RISC-V provides a highly flexible, open-source ISA foundation that is ideal for custom networking System-on-Chips (SoCs), its dynamic vector length configuration can pose severe challenges for deeply pipelined microarchitectures.13 RVV incorporates specific instructions, such as vsetvl(i), which are utilized to modify register configurations dynamically during runtime.15 Executing speculative vector instructions based on a predicted modification to these register configurations can lead to speculation failures that behave identically to mispredicted branches in a standard pipeline.15 This architectural characteristic heavily penalizes the execution of small, mixed-precision SIMD functions that are commonly found in network packet parsing algorithms, where the CPU must rapidly shift between inspecting small 8-bit headers and processing wider 64-bit payload chunks.15 The meaning of RISC-V vector instructions can become heavily dependent on instructions executed arbitrarily earlier in the pipeline, creating data hazards.15 Nevertheless, ongoing hardware optimizations targeting memory access patterns, such as the implementation of advanced shift networks, are continually advancing the performance and efficiency of vector processors in demanding networking contexts.14

The Memory Hierarchy and the Discontents of Data Movement

Because the execution units of a modern CPU operate at frequencies several orders of magnitude faster than main memory (Dynamic Random Access Memory, or DRAM), the CPU almost never accesses main memory directly for execution.12 Instead, the Memory Management Unit (MMU) orchestrates a highly complex virtual-to-physical address translation mechanism via hierarchical page tables and a Translation Lookaside Buffer (TLB).11 The MMU manages the flow of data, mapping memory blocks into the Level 1 (L1), Level 2 (L2), and Level 3 (Last-Level Cache, LLC) cache hierarchies.9

The latency disparity between an L1 cache hit (which resolves in roughly 1 to 2 nanoseconds) and a main memory fetch (which can easily exceed 100 nanoseconds) represents a critical bottleneck for network-bound workloads.17 Memory access latency, especially in large-scale systems, introduces significant processing delays if not strictly optimized.17 When incoming network packets are written directly to main memory via legacy Direct Memory Access (DMA) paradigms, the CPU suffers severe cache miss penalties when attempting to process the headers, an issue that requires advanced cache-injection architectures to resolve.

Physical Memory Characteristics: SRAM versus DRAM

At the physical hardware level, the choice of memory technology for both the CPU caches and the Network Interface Card dictates the system's line-rate capabilities, latency profile, and physical footprint. The industry relies primarily on two distinct semiconductor memory architectures: Static Random Access Memory (SRAM) and Dynamic Random Access Memory (DRAM).19

Architectural Feature	Static Random Access Memory (SRAM)	Dynamic Random Access Memory (DRAM)
Physical Construction	Built using flip-flop transistor circuits.	Built using capacitor and transistor pairs.
Access Latency	Ultra-fast access times (as low as 10 nanoseconds).	Considerably slower access speeds.
Power and Refresh	Consumes steady, small current; requires no refreshing.	Requires constant electrical refreshing to prevent data loss.
Density and Cost	Low physical density; highly expensive to manufacture.	High physical density; highly cost-effective for mass storage.
System Utilization	On-chip CPU caches, NIC descriptor rings, TCAM lookup tables.	Off-chip main memory, deep packet buffering in routers/NICs.

Table 1: Architectural Comparison of SRAM and DRAM Technologies in Computing Systems 19

As demonstrated in the architectural comparison, SRAM provides superior performance with significantly lower power requirements, making it ideal for the internal L1/L2 caches of the CPU and for high-speed lookup operations within the network module.19 However, its high cost and immense physical footprint per bit preclude its use as mass storage.19 DRAM, utilizing microscopic capacitors to hold electrical charge, provides the massive density required for host system memory and deep network buffers, but introduces the penalty of constant refresh cycles and high latency.19 To sustain 100 Gbps to 400 Gbps line rates across thousands of concurrent network interfaces, advanced packet buffer designs on modern internet modules must utilize a sophisticated hybrid memory architecture.21 Fast, multi-ported SRAM is deployed for critical path operations like descriptor rings, Exact Match hash tables, and ternary content-addressable memory (TCAM) routing lookups, while deep, off-chip DRAM banks are leveraged to absorb transient traffic microbursts that temporarily exceed the processor's forwarding rate.19

Advanced Internet Module and SmartNIC Architectures

The architecture of the internet module, traditionally referred to as the Network Interface Card (NIC), has evolved over the past decade into a highly complex, autonomous computing subsystem in its own right.2 The trajectory has moved from a standard electrical transceiver to an intelligent SmartNIC capable of executing complex user-space logic independently of the host CPU.2

Foundational Network Datapath Components

At the absolute lowest architectural level, the network module comprises the Physical Layer (PHY), the Physical Coding Sublayer (PCS), and the Media Access Control (MAC) unit.25 The PHY interface physically connects the silicon to the analog transmission medium, which may be copper cabling or optical fiber transceivers (such as QSFP28 modules), converting analog waveforms or light pulses into a digital bitstream.25

The digital signal is then passed to the Ethernet Controller, where the MAC layer oversees framing, physical addressing, and fundamental error detection, typically utilizing Frame Check Sequences to ensure data integrity.25 Once a frame successfully passes the MAC layer inspection, it crosses a Packet Interface and is temporarily held in a localized First-In-First-Out (FIFO) hardware buffer before it can be processed by higher-level logic or transferred across the system interconnect.25

The Emergence of the SmartNIC and Infrastructure Processing Unit

The modern SmartNIC, frequently classified within the industry as an Infrastructure Processing Unit (IPU) or Data Processing Unit (DPU), fundamentally re-architects the traditional server chassis by physically and logically separating tenant applications from infrastructure management.2 By offloading networking, security filtering, storage initiation (e.g., NVMe over Fabrics), and complex data movement tasks directly to the NIC, the expensive host CPU cores are preserved entirely for running revenue-generating workloads.2 This modular separation also dramatically simplifies tenant applications and increases their portability across diverse cloud infrastructures.2

The taxonomy of SmartNIC hardware architectures falls into three primary, distinct paradigms, each offering a specific trade-off between performance, power efficiency, and programmability:

SmartNIC Architecture	Hardware Paradigm	Operational Characteristics and Use Cases
System-on-Chip (SoC)	Multi-core processors coupled with domain-specific accelerators.	Integrates general-purpose ARM or MIPS cores alongside packet engines. Runs autonomous embedded OS (e.g., Ubuntu). Highly programmable using standard C/C++ or DPDK.23
Field Programmable Gate Array (FPGA)	Reconfigurable hardware logic blocks and routing channels.	Offers true hardware-level programmability via Verilog or P4. Allows silicon logic to "morph" post-deployment to support evolving protocols or custom AI inference tasks.2
Application-Specific Integrated Circuit (ASIC)	Hardcoded, fixed-function silicon logic specifically designed for networking.	Delivers the absolute highest throughput and lowest thermal/power envelope for fixed tasks, but entirely lacks post-silicon adaptability for new protocols.23

Table 2: Taxonomy of Modern SmartNIC and DPU Hardware Architectures 2

SmartNICs utilize highly sophisticated internal traffic managers and specialized NIC switching logic to steer incoming packets to the appropriate internal execution engines.23 Depending on the classification of the packet, the traffic manager may route the data to an embedded flow engine executing a P4 programmable pipeline, to a dedicated cryptography accelerator for inline IPsec/TLS decryption, or to the multi-core CPU cluster for complex, stateful Deep Packet Inspection (DPI).23

To facilitate open-source innovation, platforms like the OpenNIC shell provide a pre-developed Register-Transfer Level (RTL) design targeting FPGA-based NICs, such as the AMD-Xilinx Alveo series.2 The OpenNIC architecture provides up to four PCIe physical functions (PFs), supports multiple transmit and receive queues with Receive-Side Scaling (RSS), and exposes well-defined control and data interfaces for engineers to integrate custom user logic.2 Furthermore, advanced Adaptive SoCs go a step further by integrating native AI Engines directly into the SmartNIC fabric, enabling real-time infrastructure tasks such as network anomaly detection, DDoS prevention, and heuristic ransomware identification operating at line rate.2 These modular architectures align with the Open Compute Platform (OCP) standards, frequently integrating a Hardware Root-of-Trust (RoT) for secure boot and key management, alongside a Baseboard Management Controller (BMC) for out-of-band server management.2

Bridging the Compute-Network Divide: System Interconnects

The physical and logical integration between the host CPU and the network module ultimately defines the overall latency, throughput, and power efficiency of the entire computing system. Highly inefficient data movement across the system bus results in processor stalls, massive cache pollution, and catastrophic packet drops.26

The Mechanics of Direct Memory Access and Interrupt Handling

Direct Memory Access (DMA) acts as a critical, asynchronous hardware co-processor mechanism, enabling the NIC to read and write data directly to the host system memory without requiring continuous, active intervention from the CPU.28 Without the existence of DMA, the CPU would be forced to execute Programmed I/O (PIO), a process that wastes thousands of valuable execution cycles merely copying data words from the peripheral device into main memory.28 While polled PIO might suffice for extremely low-speed legacy peripherals, it is an untenable architectural design at gigabit and terabit speeds, where it would entirely consume all available CPU resources.30

The modern DMA architecture operates heavily on the concept of Descriptor Rings, or Ring Buffers—fixed-size circular FIFO queues strictly located within coherent host RAM.31 The network card maintains highly specialized hardware registers that point to the physical base address of the Receive (RX) and Transmit (TX) rings in RAM.31 When an incoming packet arrives at the NIC, the hardware initiates a DMA transfer over the system bus, writing the packet payload into a pre-allocated streaming buffer in RAM, and subsequently updating a descriptor entry in the RX ring to indicate the length and status of the new packet.31

Once the data safely resides in RAM, the NIC issues a hardware interrupt signal to notify the CPU.32 The CPU must instantly halt its current pipeline activities, save its architectural state, retrieve the memory address of the specific interrupt handler from the interrupt vector table, and execute the networking routine.33 Upon completion, the CPU restores its previous state and resumes normal execution.33 However, at 100 Gbps speeds, issuing a hardware interrupt for every single packet causes an "interrupt storm," completely paralyzing the CPU with context-switching overhead.34 To mitigate this, modern network drivers employ hybrid polling mechanisms, such as the Linux New API (NAPI). Under NAPI, the first packet triggers a hardware interrupt, which then schedules a software interrupt (softirq) that disables further hardware interrupts and actively polls the RX ring buffer, consuming packets continuously until the queue is exhausted, thereby balancing latency with CPU efficiency.32

System-on-Chip Communication: The AMBA AXI4 Protocol

Within highly integrated SoC designs and FPGA-based SmartNIC architectures, communication between the embedded CPU cores (such as an ARM Cortex or Xilinx MicroBlaze) and the custom network intellectual property (IP) blocks relies on advanced, standardized on-chip interconnect protocols, predominantly the Advanced Microcontroller Bus Architecture (AMBA) AXI4.22

The AXI4 protocol provides a high-performance, high-frequency, point-to-point interconnect framework that intentionally decouples the address phase from the data phase.36 This architectural decoupling enables multiple outstanding transactions and supports out-of-order transaction completion, maximizing bus utilization.38 A fully compliant AXI4 system consists of masters, slaves, arbiters, and address decoders, operating across five distinct, independent channels: Write Address, Write Data, Write Response, Read Address, and Read Data.39 For example, when two master components attempt to initiate a transaction simultaneously, a central arbiter dictates bus priority, while a centralized decoder interprets the address sent by the master to route the control signals to the correct slave peripheral.39 A typical AMBA AXI4 design might operate at a frequency of 100MHz (yielding a 10-nanosecond clock cycle), allowing a single read operation to execute in 160 nanoseconds and a single write operation to complete in 565 nanoseconds.39

The AXI4 protocol is strategically deployed in three distinct subsets depending on the specific networking requirement:

• AXI4-Full: Supports ultra-high-bandwidth, memory-mapped data transfers with variable burst lengths ranging from 1 to 256 beats, and transfer widths scaling up to 1024 bits.36 This protocol is ideal for high-volume DMA packet transfers.36

• AXI4-Lite: A radically simplified subset strictly limited to single-beat transactions, where all data accesses match the width of the data bus.36 This protocol is utilized by the embedded CPU to configure memory-mapped control registers within the NIC, such as setting MAC addresses, adjusting TCAM routing entries, or initializing ring buffer pointers.22

• AXI4-Stream: A unidirectional, address-less protocol optimized for continuous, high-speed data flows from a master to a slave.36 By eliminating address routing overhead, AXI4-Stream is ideal for moving raw packet payloads from the MAC layer directly into deep packet processing pipelines within an FPGA, drastically reducing signal routing complexity and preserving logic gates.36

Advanced Cache Injection: Intel Data Direct I/O (DDIO)

Under legacy DMA architectures spanning the PCIe bus, inbound transactions explicitly target the host's main memory (DRAM). If the host CPU needs to inspect a packet header for routing or firewalling, it must subsequently fetch that data from the slow DRAM into its L1 cache, incurring massive latency penalties.18

To fully comprehend the severity of this hardware bottleneck, one must consider the mathematical realities of a 100 Gbps Ethernet link. When a 100G NIC is fully saturated with minimum-sized 64-byte packets (plus 20 bytes of standard Ethernet framing overhead), the NIC receives a new packet precisely every 6.72 nanoseconds.18

For a modern CPU core running at 3.0 GHz, 6.72 nanoseconds equates to roughly 20 internal clock cycles.18 Because a standard DRAM fetch latency is 5 to 10 times longer than this microscopic packet inter-arrival timeframe, packets will inevitably be dropped if the CPU relies on traditional DRAM fetching.18

Intel's Data Direct I/O (DDIO) technology fundamentally re-architects this interaction. DDIO enables the NIC to perform DMA read and write operations directly into the CPU's Last-Level Cache (L3 LLC), bypassing the slow main memory entirely.18 This mechanism places the incoming network packet data as close to the CPU execution cores as physically possible.18 By satisfying core and I/O interactions strictly within the L3 cache, DDIO drastically increases overall performance, lowers response latency for high-frequency trading applications, and significantly reduces the server's overall power consumption by eliminating the electrical signaling required to push data to external DRAM DIMMs.41 However, to realize these theoretical performance gains, system architects must ensure strict Non-Uniform Memory Access (NUMA) topology alignment; the PCIe NIC, the pinned memory buffers, and the consuming CPU core must all physically reside on the exact same CPU socket to prevent cross-interconnect latency.18

The Compute Express Link (CXL) Paradigm Shift

While modern iterations of PCIe (such as Gen 4.0 and Gen 5.0) offer substantial raw bandwidth, the PCIe protocol is fundamentally constrained by its non-cache-coherent nature and its strict reliance on high-overhead DMA and Memory-Mapped I/O (MMIO) semantics.8 Host-to-device MMIO writes across the PCIe bus suffer from extreme latency—often exceeding 8 microseconds just to transfer 512 bytes—and are severely bandwidth-constrained, peaking at under 0.3 GB/s.8 This heavily penalizes the synchronization of doorbell registers and the continuous updating of ring pointers necessary for network processing.8 Furthermore, the lack of hardware cache coherence forces the operating system to rely on complex software-managed synchronization, requiring resource-intensive explicit cache flushing, memory pinning, and the implementation of software memory barriers to ensure data consistency between the CPU and the NIC.8

The Compute Express Link (CXL) standard revolutionizes end-host networking architecture by replacing the legacy PCIe protocol with a hardware-managed, cache-coherent fabric built physically upon the PCIe electrical layer.8 CXL enables true load/store semantics, replacing cumbersome, multi-step DMA setup phases with native, low-latency CPU memory instructions.8

The re-architecting of the network interface utilizes two primary CXL protocols:

1. CXL.cache (Type-1 CXL-NIC): This protocol allows the network module to coherently cache host CPU memory.8 This architectural design replaces slow, legacy PCIe MMIO synchronization with incredibly fast, cache-line-granular transactions. This allows the host CPU and the NIC to share control structures and packet data directly within a single coherent memory space, bypassing MMIO overhead entirely.8

2. CXL.mem (Type-2 CXL-NIC): This protocol allows the host CPU to natively map and access memory that physically resides on the network module, utilizing standard load/store instructions.8 In a Type-2 CXL-NIC design, cache-coherent DRAM on the SmartNIC is exposed to the host CPU, yielding 5.6x lower latency for memory loads and 4.5x lower latency for memory stores compared to legacy MMIO.8 This paradigm facilitates the highly flexible placement of descriptor rings and packet buffers directly on the network device, which heavily reduces host memory pressure and has been empirically proven to reduce tail latencies for network packet processing by an impressive 49%.8

Hardware Offloading: The TCP/IP Processing Conundrum

The traditional implementation of the Transmission Control Protocol/Internet Protocol (TCP/IP) stack within the host operating system's software kernel is a primary source of CPU exhaustion in modern networking.7 Context switching between user-space applications and the kernel, data copying across memory boundaries, and the software-based calculation of cyclic redundancy checks and checksums consume immense computational resources.45 As bandwidth increases, processor time is entirely consumed by handling incoming frames rather than executing user algorithms, negatively impacting network efficiency and degrading real-time applications.45

The Evolution and Failure of Early TCP Offload Engines

To solve this computational bottleneck, the industry naturally gravitated toward transferring resource-intensive computational tasks to a separate co-processor.3 The concept of a TCP Offload Engine (TOE), wherein the entire stateful TCP connection—including flow control, congestion avoidance, sliding windows, and reassembly—is maintained by hardcoded silicon on the NIC, has a complex and highly debated history.34

Despite immense hype in the early 2000s, attempts at creating a ubiquitous full-stack TOE failed in widespread enterprise adoption for several critical architectural reasons:

1. Hardware Inflexibility: Hardcoding a protocol as monstrously complex and evolving as TCP into ASIC logic makes bug fixing and security patching nearly impossible.35 Hardware implementations cannot easily adapt to new TCP variants (e.g., BBR congestion control) without complete firmware or silicon replacements.35

2. Invasive Kernel Integration: Transparently migrating socket states between the host operating system and the NIC required highly invasive, non-standard modifications to the host kernel.35 While Microsoft attempted to bridge this gap with the "TCP Chimney" architecture, the open-source Linux community heavily rejected full offload due to the sheer complexity and instability it introduced to the networking stack, rendering TOE a non-starter in standard Linux distributions.35

3. Edge Case Latency Penalties: The computational cost of establishing a fully offloaded connection state in hardware is fixed. For short-lived, transient connections (such as HTTP requests handling small files), the overhead of setting up the TOE state often exceeded the latency of simply processing the transaction entirely in software, resulting in worse overall performance.35

Consequently, rather than full stateful offloading, the industry initially pivoted to highly successful, stateless partial offloads.35 Modern commodity NICs universally support features such as TCP Segmentation Offload (TSO), Large Receive Offload (LRO), and protocol-agnostic TCP/IP checksum calculation.35 In these architectures, the host kernel maintains full control over connection state and congestion algorithms, while the hardware NIC handles the computationally heavy lifting of fragmenting massive, multi-kilobyte buffers into MTU-sized Ethernet frames, drastically reducing the number of costly DMA transfers and interrupt requests required.35

The Modern Renaissance of Network Offloading

Despite historical resistance in general-purpose computing, full hardware TCP stacks have found immense success in specific niche domains, particularly in ultra-low latency trading, medical imaging, industrial automation, and embedded IoT devices where CPU resources are severely constrained or power efficiency is paramount.7

Offload Approach	Implementation Environment	Performance Characteristics and CPU Utilization
Traditional Software TCP/IP	Host CPU Kernel (Linux/Windows)	100% CPU load during high-throughput transfers. Highly susceptible to dropped packets and latency spikes under heavy load.7
Hardware TOE IP Core (FPGA)	Embedded FPGA Systems (e.g., Xilinx Zynq)	0% Host CPU usage. Full stack processed in hardware logic yielding 99% stable transfer speeds with microsecond latency.7
User-Space Polling (DPDK)	General-purpose Host CPU or DPU Cores	Bypasses the OS kernel entirely. Uses zero-copy memory pointers. Extremely high throughput but dedicates entire CPU cores to polling.46

Table 3: Performance Comparison of Modern TCP/IP Offload Mechanisms 7

Modern FPGA-based TOE implementations, such as the TOE10G-IP core from Design Gateway or WIZnet's hardware TCP/IPv4v6 stacks, can execute sustained 10 Gbps transfers without requiring any CPU intervention or external memory, fundamentally outperforming unstable software variants running on embedded Linux platforms.7

Furthermore, in hyperscale cloud data centers, a new hybrid "Plug & Offload" (PnO) approach is emerging. Rather than hardcoding TCP logic into rigid ASIC silicon, the entire TCP stack is ported into lightweight, user-space polling mode drivers leveraging the Data Plane Development Kit (DPDK).46 This user-space stack runs autonomously on the general-purpose ARM cores of an off-path DPU or SmartNIC (such as the NVIDIA BlueField).46 This architecture provides the performance benefits of offloading—freeing the host CPU and boosting requests-per-second by up to 127% for small packet scenarios in real-world applications like Redis and HAProxy—while completely retaining the flexibility and programmability of standard software.46 DPDK achieves this massive throughput by bypassing the host kernel entirely, implementing zero-copy memory semantics by passing memory pointers directly between the NIC rings and the user-space application, eliminating all superfluous data copies and context switches.47

Hardware Security Architectures for Network-Attached Devices

The integration of highly autonomous, DMA-capable devices into the server architecture creates massive, systemic security vulnerabilities. Because traditional DMA inherently bypasses the CPU's Memory Management Unit (MMU), a compromised, faulty, or intentionally malicious Network Interface Card has the theoretical capability to read or modify any arbitrary physical memory address in the host system.52 This access allows an attacker to subvert operating system protections, exfiltrate sensitive cryptographic keys, or inject malicious code directly into the kernel runtime.52 These attacks can originate from remote takeovers of NIC firmware or from the physical introduction of malicious hardware into the server chassis.53

The Input-Output Memory Management Unit (IOMMU)

To enforce strict memory isolation and protect the host from rogue PCIe devices, modern computing architectures place an Input-Output Memory Management Unit (IOMMU) physically between the PCIe interconnect bus and the main system memory.52 In ARM-based architectures, this critical security component is implemented as the System Memory Management Unit (SMMU v3).55

The IOMMU/SMMU architecture provides three foundational security guarantees:

1. Translation Services: The SMMU intercepts memory access requests from the peripheral, treating the device-supplied addresses not as physical memory, but as I/O Virtual Addresses (IOVAs). It translates these IOVAs into actual system physical addresses utilizing device-specific translation tables, mirroring the operation of the CPU's internal MMU.53

2. Protection and Isolation: The SMMU enforces strict read, write, and execute permissions based on the rights held in the translation tables. It ensures that a given peripheral can only access the precise regions of memory explicitly mapped and granted to it by the host hypervisor or operating system, securely isolating transactions from multiple devices sharing the same SMMU.52

3. Granule Protection Checks: In highly advanced secure architectures utilizing the ARM Realm Management Extension (RME), the SMMU dynamically checks memory page assignments against a hardware-based Granule Protection Table.55 This ensures that access to memory locations assigned to distinct Physical Address Spaces (PAS) is rigorously isolated between secure and non-secure states.55

Critical Vulnerabilities in IOMMU Implementations

Despite the theoretical protection offered by the IOMMU, deep systemic vulnerabilities persist across the hardware and software lifecycle, exposing systems to severe exploitation.

Early-Boot DMA Attacks and UEFI Failures: A highly critical security flaw recently discovered in numerous modern motherboard models (affecting vendors such as ASRock, ASUS, MSI, and GIGABYTE across Intel and AMD chipsets under CVE-2025-14304 and CVE-2025-11901) highlights the fragility of hardware security initialization.54 The vulnerability stems from a catastrophic failure within the Unified Extensible Firmware Interface (UEFI) to properly configure and enable the IOMMU during the highly sensitive early-boot phase.54

While the system firmware erroneously reports to the user that DMA protection is active, the IOMMU hardware is physically bypassed.54 This discrepancy creates a massive attack surface. An attacker with physical access can connect a malicious DMA-capable PCIe device (or exploit a vulnerable embedded network controller) to execute unauthorized DMA read and write operations. Because the operating system's kernel-level defenses have not yet loaded, the attacker can alter the initial state of the system, access sensitive data in memory, and inject persistent, pre-boot malicious code that undermines the integrity of the entire boot process.54 Without enforcing strict hardware-level architectures—such as correctly implementing ARM TrustZone alongside appropriately configured AXI-bus Non-Secure (NS) bits—even sophisticated systems fall prey to these profound firmware logic errors, enabling privilege escalation through raw DMA memory reading.60

The Deferred Protection Vulnerability Window: Beyond boot-time failures, standard intra-OS protection mechanisms introduce severe runtime vulnerabilities. Operating systems dynamically map an IOVA precisely when a network driver requests a DMA operation, and subsequently destroy that mapping (unmap) the moment the data transfer completes to minimize exposure.53 However, mathematically, destroying an IOMMU mapping requires actively invalidating the hardware I/O Translation Lookaside Buffer (IOTLB).53 This invalidation is a severely slow hardware operation, consuming approximately 2,000 CPU cycles on modern processors and requiring strict, multi-core synchronization locks.53

To maintain high packet throughput and prevent the system from bottlenecking on IOTLB locks, operating systems universally utilize a technique known as "deferred protection," intentionally batching hardware invalidations to execute them simultaneously at a later interval.53 This architectural compromise creates a highly exploitable vulnerability window spanning anywhere from 10 microseconds up to 10 milliseconds.53 During this window, an unmapped buffer remains entirely accessible to the NIC.53 A malicious network device or compromised firmware could wait for an incoming packet to successfully pass the software firewall inspection, and then immediately overwrite the validated payload with malicious code via DMA before the deferred IOTLB invalidation executes.53 The unmapped buffer may even be reused by the OS for entirely different, sensitive data, exposing that data to the NIC.53

Sub-page Protection and Shadow Buffering Mitigation: Furthermore, because IOMMUs operate physically at the page granularity level (typically 4 KB blocks), they inherently suffer from sub-page security vulnerabilities.53 Standard 1500-byte Ethernet Maximum Transmission Units (MTUs) do not fill an entire 4 KB page. Consequently, multiple buffer allocations often share the exact same physical page.53 A compromised NIC could thus freely read adjacent, unmapped sensitive data that happens to be co-located on the same physical page as the authorized network buffer.53

To comprehensively mitigate both the deferred protection vulnerability window and the lack of sub-page protection, advanced security architectures employ a "Shadow Buffer" (or "Copy") model, which fundamentally alters how the IOMMU is utilized.53 Instead of constantly mapping and unmapping transient buffers and thrashing the slow IOTLB hardware, the operating system maintains a set of permanently mapped, highly isolated shadow DMA buffers.53 The CPU then manually copies data between the secure application space and the shadow buffer.53

While copying data appears counterintuitive to performance, this copying paradigm completely removes the need for IOTLB invalidations and complex synchronization locks. This achieves true byte-granularity (sub-page) protection while paradoxically increasing overall packet throughput by up to 5x over the strictest preexisting hardware identity mapping models, simultaneously reducing CPU consumption by 2.5x.53 For specific workloads involving exceptionally large DMA buffers where copying is too inefficient, the architecture adapts by copying only the sub-page head and tail of the buffer while mapping the bulk data, maintaining security with minimal overhead.53

Architectural Resilience Against Speculative Side-Channel Exploits

The high-profile discovery of side-channel hardware vulnerabilities, specifically Spectre and Meltdown, has forced a critical re-evaluation of speculative execution across all networked environments.61 Meltdown physically breaks the fundamental isolation between user applications and the operating system cache by exploiting speculative out-of-order execution, allowing a rogue process to read unauthorized arbitrary memory.63 Spectre, operating on a different vector, tricks error-free applications into leaking their secrets via branch misprediction.63

While the primary CPU datapath is profoundly vulnerable to these architectural attacks, discrete GPU and NIC architectures possess natural immunities due to their distinct design philosophies.65 Network modules and GPUs prioritize explicit parallelism (scaling via massive multi-threading) over the implicit, speculative out-of-order parallelism utilized by standard desktop and server CPUs to maximize single-thread performance.65 Furthermore, their internal memory mapping and custom microcode do not share or mimic the highly privileged execution ring structures of the host CPU.65

However, this dynamic is changing. As SmartNICs increasingly integrate general-purpose ARM processing cores capable of executing complex user-space programs—such as the experimental Wave framework, which successfully offloaded entirely Linux kernel thread scheduling, RPC stacks, and memory management directly to SmartNIC ARM cores—the attack surface expands.24 Hardware architects must ensure that these embedded SoCs deploy robust hardware mitigations against speculative cache timing attacks to prevent a compromised NIC tenant from reading the memory of a co-tenant processing secure network streams.24

Emerging Paradigms for Latency Minimization and Next-Generation Integration

Looking forward, minimizing end-to-end latency across the CPU-Internet boundary requires systemic, multi-layered optimization encompassing the physical optical layer, the network topology, and raw data encoding methodologies.

To achieve microsecond-scale latency, system designers must fundamentally minimize hardware hops and consolidate the physical distance between the processing unit and the data.5 This involves employing rigorous I/O prioritization and protocol optimization, alongside software connection pooling to reduce the physical signaling overhead generated by multiple individual requests.17

At the hardware level, researchers are exploring radical departures from traditional boolean logic. The Hybrid Temporal Computing (HTC) framework leverages both pulse rate and temporal data encoding—where data values are encoded as single physical delays rather than rapid logic state switches—leading to ultra-low energy hardware accelerators that significantly reduce signal switching overhead.66 In data-intensive networking applications, Near-Memory Acceleration is proving highly effective. By embedding a high-throughput parallel hash table directly within FPGA XOR-based multi-ported SRAM, systems can execute complex key-value indexing logic at deterministic line rates without suffering from data-dependent performance degradation.67 This architecture completely eliminates the PCIe bottleneck, achieving nearly 6000 Million Operations Per Second (MOPS) on Xilinx Alveo platforms, unifying the TCP/IP stack and application logic at the hardware level to entirely suppress retransmission loops and congestion.67

Finally, the physical transport layer itself is undergoing a transformation to support the massive scale-up requirements of models like DeepSeek-V3 and advanced Multi-Token Prediction Modules.68 To overcome the severe thermal and bandwidth limitations of traditional copper SERDES interconnects, architectures are deploying "wide-and-slow" topologies utilizing optical circuit switching and MicroLEDs, breaking the copper-optics tradeoff to provide essentially infinite high-bandwidth domains for data center scale AI training.69

Conclusion

The architectural design of modern Central Processing Units and internet network modules has definitively transcended the simplistic, legacy pipeline of a host processor writing fragmented bytes to a passive peripheral. To support the relentless, exponential scaling of global network traffic and sophisticated cloud workloads, hardware architects must view the entire server chassis as a holistic, tightly integrated, and distributed computing fabric.

The CPU must aggressively leverage highly specialized ISA extensions—navigating the architectural trade-offs between dynamic and fixed vector processing—to optimize packet parsing deep within the datapath. System interconnects must continue their urgent transition away from legacy, high-latency PCIe DMA operations toward cache-coherent Compute Express Link (CXL) fabrics that support native, low-latency load/store semantics, radically lowering the boundary between local memory and the network interface. Network interfaces themselves have effectively evolved into specialized computers—SmartNICs, DPUs, and IPUs—capable of absorbing the immense computational burden of TCP offloading, packet steering, and inline traffic encryption, thereby liberating the host CPU for revenue-generating execution.

Simultaneously, as these highly autonomous, DMA-capable devices gain direct, high-speed access to the system memory hierarchy, physical hardware security cannot remain an afterthought. Robust SMMU implementations, secure boot firmware verified by hardware roots-of-trust, and highly innovative architectural paradigms—such as shadow buffering and hardware copy mechanisms—are absolute necessities to thwart devastating early-boot DMA attacks and close the exploitable vulnerability windows inherent in deferred IOTLB invalidation. By rigorously harmonizing cache management algorithms, coherent interconnect protocols, programmable hardware acceleration, and robust security isolation, system designers can successfully shatter the CPU bottleneck, delivering the extraordinary latency, throughput, and resilience demanded by next-generation networked applications.

Works cited

1. Central processing unit - Wikipedia, accessed February 21, 2026, https://en.wikipedia.org/wiki/Central_processing_unit

2. White Paper | ADAPTIVE SMARTNICS FOR FUTURE DATA ... - AMD, accessed February 21, 2026, https://www.amd.com/content/dam/amd/en/documents/products/accelerators/alveo/adaptive-smartnic-white-paper.pdf

3. Should I offload my networking to hardware? A look at hardware offloading - Red Hat, accessed February 21, 2026, https://www.redhat.com/en/blog/should-i-offload-my-networking-hardware-look-hardware-offloading

4. Network Interface Design for Low Latency Request-Response Protocols - USENIX, accessed February 21, 2026, https://www.usenix.org/system/files/conference/atc13/atc13-flajslik.pdf

5. Six Design Principles to Help Mitigate Latency - Verizon, accessed February 21, 2026, https://www.verizon.com/business/en-au/resources/articles/six-design-principles-to-help-mitigate-latency/

6. An Efficient Architecture for a TCP Offload Engine Based on Hardware/Software Co-design, accessed February 21, 2026, https://www.researchgate.net/publication/220587221_An_Efficient_Architecture_for_a_TCP_Offload_Engine_Based_on_HardwareSoftware_Co-design

7. Proven 10G TCP Offload Engine IP Core for Industrial, Medical, and Test & Measurement Applications, accessed February 21, 2026, https://dgway.com/blog_E/2024/09/19/proven-10g-tcp-offload-engine-ip-core-for-industrial-medicaland-test-measurement-applications/

8. Re-architecting End-host Networking with CXL ... - Saksham Agarwal, accessed February 21, 2026, https://saksham.web.illinois.edu/assets/pdf/cxl-nic.pdf

9. Components of the CPU - Dr. Mike Murphy, accessed February 21, 2026, https://ww2.coastal.edu/mmurphy2/oer/architecture/cpu/components/

10. Instruction Set Architecture and Microarchitecture - GeeksforGeeks, accessed February 21, 2026, https://www.geeksforgeeks.org/computer-organization-architecture/microarchitecture-and-instruction-set-architecture/

11. Modern CPU Architecture 1 - Mitterand Ekole - Medium, accessed February 21, 2026, https://mitterandekole.medium.com/modern-cpu-architecture-1-921ce3ebb980

12. The central processing unit (CPU): Its components and functionality - Red Hat, accessed February 21, 2026, https://www.redhat.com/en/blog/cpu-components-functionality

13. RISC-V extensions: what's available and how to find them | Red Hat Research, accessed February 21, 2026, https://research.redhat.com/blog/article/risc-v-extensions-whats-available-and-how-to-find-it/

14. Efficient Architecture for RISC-V Vector Memory Access - arXiv.org, accessed February 21, 2026, https://arxiv.org/html/2504.08334v3

15. ARM vs. RISC-V Vector Extensions - Hacker News, accessed February 21, 2026, https://news.ycombinator.com/item?id=27063748

16. ARM vs RISC-V Vector Extensions : r/RISCV - Reddit, accessed February 21, 2026, https://www.reddit.com/r/RISCV/comments/n69kgc/arm_vs_riscv_vector_extensions/

17. Low latency Design Patterns - GeeksforGeeks, accessed February 21, 2026, https://www.geeksforgeeks.org/system-design/low-latency-design-patterns/

18. Effective Utilization of Intel® Data Direct I/O Technology, accessed February 21, 2026, https://www.intel.com/content/www/us/en/docs/vtune-profiler/cookbook/2024-1/effective-utilization-of-intel-ddio-technology.html

19. SRAM vs DRAM: Difference Between SRAM & DRAM Explained - Enterprise Storage Forum, accessed February 21, 2026, https://www.enterprisestorageforum.com/hardware/sram-vs-dram/

20. SRAM (static RAM) - Infineon Technologies, accessed February 21, 2026, https://www.infineon.com/products/memories/sram-static-ram

21. A DRAM/SRAM Memory Scheme for Fast Packet Buffers - UPCommons, accessed February 21, 2026, https://upcommons.upc.edu/bitstreams/a5cd99d6-52ea-4efb-b2d5-11d70815a524/download

22. Building a Smart Network Interface Card on FPGA – Major Project Edition | Utkar5hM, accessed February 21, 2026, https://utkar5hm.github.io/posts/smart-nic-on-fpga/

23. A Comprehensive Survey on SmartNICs: Architectures ..., accessed February 21, 2026, https://research.cec.sc.edu/files/cyberinfra/files/smartnic_survey_preparation_of_papers_for_ieee_access_1.pdf

24. Wave: Offloading Resource Management to SmartNIC Cores - arXiv, accessed February 21, 2026, https://arxiv.org/html/2408.17351v4

25. Smart NICs - Jyothi - Medium, accessed February 21, 2026, https://jyos-sw.medium.com/smart-nics-7892e012c392

26. US6434620B1 - TCP/IP offload network interface device - Google Patents, accessed February 21, 2026, https://patents.google.com/patent/US6434620B1/en

27. Analyzing NIC Overheads in Network-Intensive Workloads - Electrical Engineering and Computer Science, accessed February 21, 2026, http://eecs.umich.edu/techreports/cse/2004/CSE-TR-505-04.pdf

28. Direct memory access - Wikipedia, accessed February 21, 2026, https://en.wikipedia.org/wiki/Direct_memory_access

29. DMA - A Little Help From My Friends - Embedded.fm, accessed February 21, 2026, https://embedded.fm/blog/2017/2/20/an-introduction-to-dma

30. dma vs interrupt-driven i/o - Stack Overflow, accessed February 21, 2026, https://stackoverflow.com/questions/25318145/dma-vs-interrupt-driven-i-o

31. What is the relationship of DMA ring buffer and TX/RX ring for a network card?, accessed February 21, 2026, https://stackoverflow.com/questions/47450231/what-is-the-relationship-of-dma-ring-buffer-and-tx-rx-ring-for-a-network-card

32. Linux network ring buffers - Tungdam - Medium, accessed February 21, 2026, https://tungdam.medium.com/linux-network-ring-buffers-cea7ead0b8e8

33. Interrupts & DMA Basics - NamasteDev Blogs, accessed February 21, 2026, https://namastedev.com/blog/interrupts-dma-basics-2/

34. TCP offload is a dumb idea whose time has come - USENIX, accessed February 21, 2026, https://www.usenix.org/legacyurl/hotos-ix-151-paper-55

35. AccelTCP: Accelerating Network Applications with Stateful TCP Offloading - USENIX, accessed February 21, 2026, https://www.usenix.org/system/files/nsdi20spring_moon_prepub.pdf

36. AMBA® AXI4 Interface Protocol - AMD, accessed February 21, 2026, https://www.amd.com/en/products/adaptive-socs-and-fpgas/intellectual-property/axi.html

37. Understanding the AXI Protocol: Applications and Functionality - BLT Inc., accessed February 21, 2026, https://bltinc.com/2025/02/06/axi-protocol-applications-and-functionality/

38. AMBA AXI Protocol Specification - Arm Developer, accessed February 21, 2026, https://developer.arm.com/documentation/ihi0022/latest/

39. Design of AMBA AXI4 protocol for System-on-Chip communication - ResearchGate, accessed February 21, 2026, https://www.researchgate.net/publication/348410616_Design_of_AMBA_AXI4_protocol_for_System-on-Chip_communication

40. Design of AMBA AXI4 protocol for System-on-Chip communication - SciSpace, accessed February 21, 2026, https://scispace.com/pdf/design-of-amba-axi4-protocol-for-system-on-chip-2nc1qywqgt.pdf

41. Effective Utilization of Intel® Data Direct I/O Technology, accessed February 21, 2026, https://www.intel.com/content/www/us/en/docs/vtune-profiler/cookbook/2023-1/effective-utilization-of-intel-ddio-technology.html

42. Intel® Data Direct I/O Technology (Intel® DDIO): A Primer, accessed February 21, 2026, https://www.intel.com/content/dam/www/public/us/en/documents/technology-briefs/data-direct-i-o-technology-brief.pdf

43. Intel® Data Direct I/O Technology, accessed February 21, 2026, https://www.intel.com/content/www/us/en/io/data-direct-i-o-technology.html

44. Intel® Data Direct I/O Technology Performance Monitoring, accessed February 21, 2026, https://www.intel.com/content/www/us/en/developer/articles/technical/ddio-analysis-performance-monitoring.html

45. Network performance battle [hardware tcpip vs software tcpip under DDOS attack], accessed February 21, 2026, https://forum.arduino.cc/t/network-performance-battle-hardware-tcpip-vs-software-tcpip-under-ddos-attack/290298

46. Plug & Offload: Transparently Offloading TCP Stack onto Off-path SmartNIC with PnO-TCP, accessed February 21, 2026, https://arxiv.org/html/2503.22930v1

47. Optimizing Computer Applications for Latency: Part 1: Configuring the Hardware - Intel, accessed February 21, 2026, https://www.intel.com/content/www/us/en/developer/articles/technical/optimizing-computer-applications-for-latency-part-1-configuring-the-hardware.html

48. Episode IV: A New Hope… for TCP Offload that is! | by Tom Herbert | Medium, accessed February 21, 2026, https://medium.com/@tom_84912/episode-iv-a-new-hope-for-tcp-offload-that-is-03fd23ca6a93

49. Re-evaluating Network Onload vs. Offload for the Many-Core Era - OSTI.GOV, accessed February 21, 2026, https://www.osti.gov/servlets/purl/1245930

50. System Design for Software Packet Processing - UC Berkeley EECS, accessed February 21, 2026, https://www2.eecs.berkeley.edu/Pubs/TechRpts/2019/EECS-2019-112.pdf

51. WIZnet TOE vs. Software TCP/IP: The Future of Efficient Networking, accessed February 21, 2026, https://wiznet.io/news/140

52. DMA Security in the Presence of IOMMUs, accessed February 21, 2026, https://dl.gi.de/bitstreams/1a7e69c5-eb7b-4ccb-b270-a119557a62e1/download

53. True IOMMU Protection from DMA Attacks: When Copy Is ... - TAU, accessed February 21, 2026, https://www.cs.tau.ac.il/~mad/publications/asplos2016-iommu.pdf

54. New UEFI Flaw Enables Early-Boot DMA Attacks on ASRock, ASUS, GIGABYTE, MSI Motherboards - The Hacker News, accessed February 21, 2026, https://thehackernews.com/2025/12/new-uefi-flaw-enables-early-boot-dma.html

55. Learn the architecture - Realm Management Extension guide, accessed February 21, 2026, https://developer.arm.com/documentation/den0126/0101/SMMU-architecture?lang=en

56. Learn the Architecture - SMMU Software Guide - Arm, accessed February 21, 2026, https://documentation-service.arm.com/static/64f59fb3bc48b0381ce07226?token=

57. Arm System Memory Management Unit Architecture Specification - kib.kiev.ua, accessed February 21, 2026, http://kib.kiev.ua/x86docs/ARM/SMMU/IHI0070F_b_System_Memory_Management_Unit_Architecture_Specification.pdf

58. VU#382314 - Vulnerability in UEFI firmware modules prevents IOMMU initialization on some UEFI-based motherboards, accessed February 21, 2026, https://kb.cert.org/vuls/id/382314

59. Vulnerability in UEFI Firmware Modules Prevents IOMMU Initialization on Certain Motherboards | Security & Technical Advisory - Gigabyte, accessed February 21, 2026, https://www.gigabyte.com/Support/Security/2338

60. Attacking ARM TrustZone using Hardware vulnerability, accessed February 21, 2026, https://www.runi.ac.il/media/zimptgqb/ron-stajnrod-thesis.pdf

61. Critical Security Vulnerabilities - Meltdown and Spectre - Affect Computers, Mobile Devices, and Servers, accessed February 21, 2026, https://security.it.miami.edu/stay-safe/sec-articles/meltdown-and-spectre/index.html

62. Meltdown and Spectre security vulnerabilities - Information Systems & Computing, accessed February 21, 2026, https://isc.upenn.edu/security/meltdown-spectre

63. Meltdown and Spectre, accessed February 21, 2026, https://meltdownattack.com/

64. Meltdown (security vulnerability) - Wikipedia, accessed February 21, 2026, https://en.wikipedia.org/wiki/Meltdown_(security_vulnerability)

65. Spectre/meltdown on a GPU - Information Security Stack Exchange, accessed February 21, 2026, https://security.stackexchange.com/questions/177049/spectre-meltdown-on-a-gpu

66. ASP-DAC 2025 Technical Program, accessed February 21, 2026, https://www.aspdac.com/aspdac2025/archive/program/program_abst.html

67. Hardware-Hybrid Key-Value Store: FPGA-Accelerated Design for Low- Latency and Congestion-Resilient In- Memory Caching - Preprints.org, accessed February 21, 2026, https://www.preprints.org/manuscript/202510.1412/download/final_file

68. Insights into DeepSeek-V3: Scaling Challenges and Reflections on Hardware for AI Architectures - arXiv, accessed February 21, 2026, https://arxiv.org/html/2505.09343v1

Proceedings of the ACM SIGCOMM 2025 Conference, accessed February 21, 2026, https://conferences.sigcomm.org/sigcomm/2025/program/papers-info/