Single Root I/O Virtualization (SR-IOV) is a hardware specification that allows a PCI Express (PCIe) device, such as a network adapter, to present itself as multiple separate virtual devices. It creates one or more Virtual Functions (VFs) from a single Physical Function (PF) , each with its own dedicated PCIe configuration space, memory-mapped I/O, and direct memory access (DMA) channels. This bypasses the hypervisor's software-based I/O virtualization layer, eliminating the performance overhead of virtual switches and enabling near-native throughput and latency for network-intensive workloads.
Glossary
SR-IOV

What is SR-IOV?
A PCI-SIG standard that enables a single physical network interface card (NIC) to be partitioned into multiple virtual functions, providing direct hardware access to virtualized workloads for near-native performance.
In a Kubernetes environment, the SR-IOV Network Device Plugin discovers and advertises VFs as allocatable resources, allowing pods to consume them directly via multus-cni. This is critical for disconnected Kubernetes for AI clusters where high-performance, low-latency networking is required for distributed model training or inference serving. By assigning a dedicated VF to a pod, the network traffic flows directly from the pod's memory space to the NIC hardware, ensuring deterministic performance and strict isolation without the CPU overhead of kernel-based bridging.
Key Characteristics of SR-IOV
Single Root I/O Virtualization (SR-IOV) is a PCI Express specification that allows a single physical network interface card (NIC) to be partitioned into multiple virtual functions, bypassing the hypervisor's software switch to deliver near-native network performance directly to pods.
Physical Function (PF)
A Physical Function is a full-featured PCIe function embedded in the SR-IOV-capable NIC. The PF acts as the management and configuration anchor for all associated Virtual Functions. It possesses full configuration capabilities, including the ability to create, provision, and manage VFs. The PF is discovered and managed by the host operating system or hypervisor, and it is the entity that handles link state changes and firmware updates. Only one PF typically exists per physical port, and it is not directly assigned to guest virtual machines or pods.
Virtual Function (VF)
A Virtual Function is a lightweight, pared-down PCIe function that represents a slice of the physical NIC's resources. Each VF contains only the essential resources for data movement: dedicated transmit and receive queues, DMA channels, and a unique PCI Requester ID. VFs lack full configuration capabilities and cannot be used to modify the underlying physical device. They are designed for direct assignment to a single pod or virtual machine via the VFIO (Virtual Function I/O) kernel framework, providing a dedicated, hardware-isolated data path with minimal CPU overhead.
PCIe Passthrough & Bypass
SR-IOV achieves its performance advantage by completely bypassing the hypervisor's virtual switch and the kernel's networking stack for data plane traffic. A VF is mapped directly into a pod's memory space using the VFIO-PCI driver, granting the workload direct hardware access. This eliminates the context switching and packet copying inherent in software-based bridging. The result is near line-rate throughput, microsecond-level latency, and zero CPU steal for packet processing, making it essential for latency-sensitive AI inference serving and high-frequency trading platforms.
Resource Isolation & QoS
Each VF operates with hardware-enforced isolation from other VFs on the same physical port. The NIC's on-chip switch enforces traffic separation, preventing one noisy neighbor from starving another of bandwidth. Advanced NICs support Quality of Service (QoS) policies configurable via the PF, allowing administrators to set minimum and maximum bandwidth guarantees per VF. This deterministic resource allocation is critical for multi-tenant Kubernetes clusters where AI training jobs must coexist with latency-bound inference serving without mutual interference.
SR-IOV Network Operator
In Kubernetes, the SR-IOV Network Operator automates the lifecycle management of SR-IOV devices. It discovers compatible NICs, configures PFs, and provisions VFs based on declarative SriovNetworkNodePolicy custom resources. The operator integrates with Multus CNI to attach VF-backed interfaces to pods as secondary networks. Key capabilities include:
- Device Plugin: Advertises available VFs to the kubelet as extended resources (e.g.,
intel.com/sriov_netdevice) - Configuration Daemon: Applies node-specific VF counts and driver settings
- Policy-Driven: Allows per-node or pool-based VF topology configuration
NUMA Alignment & Topology
For optimal performance, SR-IOV VFs must be allocated from a NIC that resides on the same NUMA node as the pod's assigned CPUs and GPU. Cross-NUMA traffic incurs significant latency penalties due to inter-socket communication. The Topology Manager kubelet component, combined with the SR-IOV device plugin, can enforce single-NUMA-node alignment policies. This ensures that a pod requesting a VF, CPU cores, and hugepages receives all resources from the same physical socket, eliminating non-uniform memory access bottlenecks for distributed AI training workloads.
SR-IOV vs. Other Kubernetes Networking Models
A technical comparison of SR-IOV against standard overlay and bridge-based networking plugins for high-throughput AI inference and training workloads in Kubernetes.
| Feature | SR-IOV | Calico (eBPF) | Flannel (VXLAN) |
|---|---|---|---|
Data Path | Direct PCIe passthrough to VF | eBPF programs in kernel | Kernel VXLAN tunnel |
Throughput vs. Bare Metal | ~99% | ~90-95% | ~70-80% |
Added Latency | < 5 µs | 10-30 µs | 50-100 µs |
CPU Overhead for Packet Processing | None (hardware offload) | Low (eBPF JIT) | High (kernel encap/decap) |
Network Policy Support | |||
Pod Live Migration Support | |||
Multi-Tenancy Isolation | Hardware-level (PCIe) | Software (eBPF/iptables) | Software (iptables) |
Requires Specialized NIC |
Enabling Efficiency, Speed & Accuracy
Intelligent Analysis, Decision & Execution
We build AI systems for teams that need search across company data, workflow automation across tools, or AI features inside products and internal software.
Talk to Us
Search across company data
Give teams answers from docs, tickets, runbooks, and product data with sources and permissions.
Useful when people spend too long searching or get different answers from different systems.

Automate internal workflows
Use AI to route work, draft outputs, trigger actions, and keep approvals and logs in place.
Useful when repetitive work moves across multiple tools and teams.

Add AI to products and internal tools
Build assistants, guided actions, or decision support into the software your team or customers already use.
Useful when AI needs to be part of the product, not a separate tool.
Frequently Asked Questions
Concise answers to the most common technical questions about Single Root I/O Virtualization, its operational mechanics, and its critical role in high-performance, air-gapped Kubernetes networking for AI workloads.
Single Root I/O Virtualization (SR-IOV) is a PCI Express (PCIe) specification that allows a single physical network interface card (NIC), known as the Physical Function (PF), to be partitioned into multiple lightweight, virtualized instances called Virtual Functions (VFs). Each VF is assigned a unique PCIe requester ID and appears to the operating system as a distinct, fully functional NIC with its own dedicated hardware resources, including transmit/receive queues and interrupts. The hypervisor or host OS directly assigns a VF to a virtual machine or container, bypassing the software-based virtual switch entirely. This direct hardware access enables near-native network performance by eliminating the CPU overhead and latency associated with paravirtualized I/O paths, making it essential for latency-sensitive AI inference serving in disconnected Kubernetes environments.
Related Terms
Core technologies and adjacent concepts that interact with SR-IOV to build high-performance, isolated networking for AI workloads in sovereign infrastructure.
NVIDIA MIG
Multi-Instance GPU technology partitions a single physical GPU into multiple isolated hardware instances, each with dedicated compute and memory resources. When combined with SR-IOV, MIG enables deterministic GPU sharing where each virtual function can be paired with a specific GPU slice, guaranteeing both network and compute isolation for concurrent inference workloads without noisy-neighbor interference.
GPUDirect RDMA
GPUDirect RDMA enables direct data transfer between GPU memory and a network interface card, bypassing system memory and the CPU entirely. When paired with SR-IOV virtual functions, this creates an ultra-low-latency path where distributed training gradients flow directly from GPU to wire without host intervention, critical for scaling large language model training across air-gapped GPU clusters.
Cilium eBPF Networking
Cilium provides API-aware network security and observability using eBPF at the kernel level. In SR-IOV environments, Cilium can enforce NetworkPolicy rules on traffic flowing through virtual functions, enabling micro-segmentation and deep packet inspection even when packets bypass the host kernel's standard networking stack via direct PCIe passthrough.
Multus CNI
Multus is a meta CNI plugin that enables Kubernetes pods to attach to multiple network interfaces simultaneously. It is the standard mechanism for attaching an SR-IOV virtual function as a secondary interface to a pod, allowing the workload to maintain a default cluster network via Calico or Flannel while receiving dedicated, line-rate access through the SR-IOV VF for data-plane traffic.
Node Feature Discovery (NFD)
NFD automatically detects and advertises hardware capabilities as Kubernetes node labels. For SR-IOV, NFD labels nodes with the available physical function models, virtual function counts, and device IDs, enabling the SR-IOV device plugin to intelligently schedule pods only onto nodes that possess the required high-performance network hardware.
DPDK (Data Plane Development Kit)
DPDK is a set of libraries and drivers for fast packet processing in userspace, bypassing the kernel network stack. SR-IOV virtual functions are commonly consumed by DPDK-based applications running inside containers, achieving poll-mode driver performance where packets move directly from the NIC to the application without kernel context switches, essential for 5G vRAN and low-latency inference serving.

About the author
Prasad Kumkar
CEO & MD, Inference Systems
Prasad Kumkar is the CEO & MD of Inference Systems and writes about AI systems architecture, LLM infrastructure, model serving, evaluation, and production deployment. Over 5+ years, he has worked across computer vision models, L5 autonomous vehicle systems, and LLM research, with a focus on taking complex AI ideas into real-world engineering systems.
His work and writing cover AI systems, large language models, AI agents, multimodal systems, autonomous systems, inference optimization, RAG, evaluation, and production AI engineering.
Partnered with leading AI, data, and software stack.
How We Work
Custom AI workflows for your Business
One-fit-all AI don't work for modern businesses. At Inferensys, we aim to understand your business & custom requirements; which we use to define most efficient agentic workflows, the data, and the tools for your business.
01
Review the use case
We understand the task, the users, and where AI can actually help.
Read more02
Pick the right approach
We define what needs search, automation, or product integration.
Read more03
Build the first useful version
We implement the part that proves the value first.
Read more04
Improve from there
We add the checks and visibility needed to keep it useful.
Read moreThe first call is a practical review of your use case and the right next step.
Talk to Us