{
  "id": "virtualization",
  "title": "Virtualization",
  "lang": "en",
  "source_lang": "en",
  "summary": "Virtualization abstracts computing resources from their physical implementation, enabling isolated execution environments, flexible resource allocation, and software-defined infrastructure.",
  "category": "computer-science",
  "subcategory": "software",
  "type": "concept",
  "aliases": [
    "Computing virtualization",
    "computer virtualization"
  ],
  "generated_at": "2026-11-02",
  "model": "pro/gpt-6.1-sol",
  "url": "https://aiwiki.page/en/virtualization/",
  "translations": {
    "zh-Hans": {
      "url": "https://aiwiki.page/zh/virtualization/",
      "json": "https://aiwiki.page/zh/virtualization.json"
    }
  },
  "sections": [
    {
      "heading": "",
      "text": "Virtualization is the creation of a logical representation of a computing resource that can be used independently of some characteristics of its physical implementation. The resource may be a processor, an entire computer, an execution environment, a storage device, or a network. A virtualization layer translates operations on the logical resource into operations on underlying resources, while controlling how those resources are shared. In its most familiar form, virtualization allows several operating systems to run concurrently on one physical machine, each inside a separate virtual machine.\n\nThe importance of virtualization lies in separating software environments from particular hardware configurations. This separation supports server consolidation, workload isolation, reproducible testing, migration between machines, and automated provisioning. It is a central enabling technology of cloud computing, although cloud computing also requires management, networking, metering, and service-delivery mechanisms that virtualization alone does not provide.\n\nVirtualization encompasses several distinct techniques rather than a single architecture. Hardware-assisted virtual machines, software emulation, operating-system containers, virtual networks, and virtual storage expose different interfaces and provide different guarantees. Their behavior depends on where abstraction is introduced, which resources remain shared, and which component ultimately controls physical execution."
    },
    {
      "heading": "Historical development",
      "text": "Modern machine virtualization emerged from efforts to share expensive mainframe computers while preserving independent execution environments. Early time-sharing systems allowed multiple users to interact with one machine, but generally placed them under a common operating system. Virtual-machine systems went further by presenting separate machine interfaces capable of supporting their own operating systems. This distinction made it possible to experiment with system software without giving every experiment its own physical computer.\n\nWork at IBM during the 1960s was particularly influential. The experimental CP-40 system ran on a modified System/360 Model 40, while CP-67 supported virtualization on the System/360 Model 67. These systems paired a control program, responsible for managing virtual machines, with the Cambridge Monitor System, an interactive single-user environment. IBM announced VM/370 in 1972, establishing a durable commercial lineage of mainframe virtualization. Mainframe virtual machines supported workload separation, compatibility, and efficient use of costly hardware long before virtualization became common on smaller servers.\n\nA theoretical foundation appeared in Gerald J. Popek and Robert P. Goldberg’s 1974 paper on virtualizable computer architectures. Their analysis connected processor instruction behavior to the possibility of constructing a virtual-machine monitor with defined properties. The work explained why some architectures supported straightforward virtualization whereas others required additional techniques. In particular, an operating system could not safely run unchanged under a simple trap-and-emulate monitor if instructions that affected or inspected privileged state failed to trap when executed without privilege.\n\nThe spread of inexpensive servers did not eliminate the value of virtualization. Instead, it changed the economic problem: organizations accumulated many machines that often ran at low average utilization. VMware introduced its first x86 virtualization product in 1999, demonstrating practical virtualization despite difficulties in the original x86 instruction set. Its approach combined direct execution with binary translation of problematic privileged code. The Xen project, introduced publicly in 2003, demonstrated another influential approach using modified guest operating systems.\n\nProcessor support subsequently reduced the need for these workarounds. Intel VT-x and AMD-V appeared in the mid-2000s, and the Kernel-based Virtual Machine facility entered the mainline Linux kernel in version 2.6.20 in 2007. Meanwhile, operating-system-level isolation developed through systems such as FreeBSD jails, Solaris Zones, and Linux namespaces and control groups. Contemporary infrastructure commonly combines these historical lines: hardware virtual machines provide machine-level boundaries, while containers organize applications within them."
    },
    {
      "heading": "Abstraction boundaries and formal properties",
      "text": "A virtualized resource is defined by the interface presented to its users, not merely by the presence of software between an application and hardware. For system virtualization, that interface includes an instruction set architecture, memory behavior, interrupts, and devices. For storage virtualization, it may be a block-addressable volume. For network virtualization, it may be an isolated addressing and forwarding domain. The same physical resource can therefore participate in several different virtualizations at once.\n\nPopek and Goldberg described three central properties of a virtual-machine monitor: equivalence, resource control, and efficiency. Equivalence means that programs execute with behavior essentially matching execution on the corresponding real machine, subject to specified differences such as timing and available resources. Resource control means that the monitor retains ultimate authority over physical resources. Efficiency means that a statistically dominant fraction of instructions executes directly rather than being interpreted. These are theoretical criteria, not a claim that every product marketed as virtualization satisfies an identical formal specification.\n\nThe relationship between sensitive and privileged instructions is central to the classical account. Sensitive instructions can change resource configuration or behave according to machine state; privileged instructions trap when executed outside an authorized privilege level. Under the assumptions of the classical model, an architecture is virtualizable by a conventional monitor when sensitive instructions form a subset of privileged instructions. The monitor can then allow ordinary instructions to execute directly and intercept operations that could compromise control. Modern processors add explicit virtualization modes and controls rather than relying solely on the original privilege structure.\n\nVirtualization overlaps with, but differs from, emulation. An emulator reproduces the behavior of another machine or interface and may translate every instruction, including across different processor architectures. A virtual machine can instead execute much of its code directly on a compatible processor. A single implementation may mix these methods: its processor execution may be hardware-assisted while its disk controller is emulated. Simulation is broader still and may model timing, circuitry, or hypothetical systems without attempting efficient execution of existing software.\n\nOther distinctions concern the execution interface. A system virtual machine hosts an operating system; a process virtual machine provides an execution environment for an individual program, often through bytecode and runtime services. A compatibility layer translates an application programming interface or application binary interface without necessarily reproducing a complete machine. Virtual memory, despite its name, does not by itself create a virtual computer: it abstracts address spaces within a memory-management system."
    },
    {
      "heading": "Hypervisor architectures",
      "text": "The component that manages machine virtualization is commonly called a hypervisor or virtual-machine monitor. It creates virtual processors, maps guest memory, mediates device access, and handles events that require intervention. The operating system inside a virtual machine is the guest; software that provides the underlying execution environment is often called the host. Terminology varies because some architectures have a conventional host operating system while others divide responsibilities among a small monitor, a management domain, and user-space processes.\n\nA traditional distinction separates Type 1 and Type 2 hypervisors. A Type 1 hypervisor operates directly above the hardware and controls its principal resources. A Type 2 hypervisor runs as an application or subsystem of a general-purpose host operating system, using that system’s scheduling, memory, and device services. VMware ESXi is a familiar Type 1 example, while desktop products such as VirtualBox are commonly classified as Type 2. The distinction is useful but incomplete because modern implementations distribute privileged and unprivileged functions across several layers.\n\nXen illustrates a split architecture. Its hypervisor controls processor and memory isolation, while a privileged management domain traditionally provides administrative functions and many device backends. Guest domains need not all have equal privileges. KVM illustrates a different arrangement: virtualization support resides in the Linux kernel, and virtual machines are managed through ordinary host processes and threads. QEMU commonly supplies device models and machine configuration around KVM’s accelerated execution. Calling such a system simply “hosted” can obscure the kernel’s direct control over hardware virtualization facilities.\n\nA virtual machine usually has more supporting components than the processor monitor alone. A device-model process may emulate controllers; a virtual firmware image initializes the guest; storage and networking backends connect it to external resources; and a management service exposes configuration operations. Guest tools may improve display integration, report guest status, or coordinate shutdown and backup. Every such component affects compatibility, reliability, or the security boundary, even when it is not described as part of the hypervisor.\n\nArchitectural choices reflect trade-offs rather than a universal hierarchy. Reusing a general-purpose operating system provides broad driver support and mature management facilities, but also introduces substantial privileged code. A smaller monitor may reduce part of the trusted computing base while still depending on complex device services elsewhere. Desktop hypervisors prioritize integration with a user’s workstation, whereas server hypervisors emphasize remote administration, resource scheduling, fault handling, and stable operation under many concurrent workloads."
    },
    {
      "heading": "Processor virtualization and execution control",
      "text": "Processor virtualization must let guest software behave as though it controls a processor while preventing it from controlling the physical machine. Ordinary arithmetic and logical instructions can often execute directly. Operations involving privilege levels, page-table configuration, interrupt control, or certain hardware registers require interception or special hardware handling. The challenge is not merely to execute instructions correctly, but also to reproduce transitions among application code, guest kernel code, interrupts, and exceptions.\n\nIn a classic trap-and-emulate design, a guest attempts a privileged operation and causes a trap into the monitor. The monitor examines the operation, updates virtual machine state, and resumes execution. Original x86 processors complicated this strategy because some sensitive instructions did not trap in the circumstances needed by a straightforward monitor. Binary translation addressed this problem by replacing selected instruction sequences with safe equivalents or calls into the virtualization layer. Unprivileged application code could still run directly, preserving much of native execution speed.\n\nHardware-assisted virtualization introduces a distinct execution context for guests. Intel VT-x and AMD-V maintain virtualization control structures that specify guest state, host state, and interception conditions. A transition from guest execution to the hypervisor is commonly called a VM exit; returning to the guest is a VM entry. The hardware can intercept selected instructions and events without requiring the guest kernel to run as an ordinary unprivileged application. These facilities complement, rather than eliminate, the processor’s conventional privilege levels.\n\nParavirtualization takes another approach: guest software knowingly cooperates with the virtualization layer. Instead of attempting an operation that must be intercepted, a modified guest issues a hypercall requesting an authorized service. Full guest-kernel paravirtualization was especially important before hardware assistance became widespread. Today, paravirtualized interfaces remain common for clocks, interrupt handling, and input/output even when the guest’s processor execution is otherwise hardware-virtualized.\n\nA virtual CPU is a schedulable representation of processor state, not a permanent reservation of one physical core. A guest with eight virtual CPUs may run on a host that schedules those CPUs alongside many others. The monitor must preserve registers and other architectural state when switching between them. Nested virtualization adds another level: a guest hypervisor runs its own guests. Hardware and software must then coordinate intercepts and memory mappings across multiple control layers, making performance and compatibility more complex than in a single-level system."
    },
    {
      "heading": "Memory virtualization",
      "text": "Memory virtualization separates the addresses used by software from the physical locations that hold its data. A process inside a guest normally uses virtual addresses translated by the guest operating system into guest-physical addresses. Those guest-physical addresses must then map to host-physical memory. The two-stage relationship can be expressed as\n\n\\[\\text{guest virtual address} \\rightarrow \\text{guest physical address} \\rightarrow \\text{host physical address}.\\]\n\nThese stages allow each guest to maintain what appears to be its own physical memory layout without granting access to another guest’s pages.\n\nBefore widespread hardware support for second-stage translation, hypervisors often maintained shadow page tables. These combined the guest’s intended mappings with the host’s actual allocations, producing page tables usable by the processor. Changes to guest page tables had to be detected and reflected in the shadow structures. Correctness required careful handling of permissions, invalidation, and concurrent access. Workloads that frequently changed address spaces or mappings could incur substantial virtualization overhead.\n\nModern processors commonly provide second-level address translation, including Intel Extended Page Tables and AMD Nested Page Tables. The guest manages its own page tables, while the hypervisor separately controls guest-physical-to-host-physical translation. Hardware walks the required structures and caches results in translation lookaside buffers. This reduces software intervention, although additional translation levels can still increase the cost of a cache miss. Large memory pages can reduce translation pressure, but may complicate fine-grained allocation, migration, and memory reclamation.\n\nHosts can allocate more nominal guest memory than they can simultaneously back with physical RAM, a practice known as memory overcommitment. Several mechanisms support it. A balloon driver inside a guest allocates pages at the hypervisor’s request, encouraging the guest operating system to release or page out less-used contents. The host may also swap guest pages to storage, though this can create severe and unpredictable delays. Page deduplication can merge identical contents across mappings using copy-on-write, but cross-guest sharing introduces security concerns and is therefore restricted or disabled in many environments.\n\nMemory placement also affects performance independently of capacity. On non-uniform memory access systems, a processor reaches nearby memory more quickly than memory attached to another processor socket. Hypervisors may expose virtual NUMA topology and attempt to place virtual CPUs near their memory. Poor placement, excessive migration among physical processors, or a guest topology unlike the host’s actual organization can increase latency. Isolation therefore requires correct address translation, while efficient virtualization additionally requires attention to locality, bandwidth, and the memory needs of competing workloads."
    },
    {
      "heading": "Device and accelerator virtualization",
      "text": "Input/output virtualization must reconcile guest expectations with the physical device’s ownership and operating rules. A guest may expect a familiar disk controller, network interface, or graphics adapter even when the host hardware is entirely different. Device virtualization therefore concerns both the interface visible to software and the route by which data reaches real hardware. The main approaches are device emulation, paravirtualized devices, and direct assignment, with many systems combining them.\n\nEmulated devices reproduce the registers, interrupts, and data structures of a specified hardware model. This can support existing guest device drivers without modification. The disadvantage is that guest operations may require repeated transitions to a device-model process. A virtual disk request, for example, can pass through a guest driver, an emulated controller, a host storage backend, and the host’s own driver stack. Efficient implementations batch operations and avoid unnecessary data copying, but the emulated interface may still impose historical limitations.\n\nParavirtualized devices replace detailed imitation of legacy hardware with interfaces designed for virtual environments. Virtio is a widely used family of such interfaces. A guest frontend and host backend exchange requests through shared-memory queues, reducing the need to emulate individual device registers. The guest still needs a suitable driver, but the interface can remain stable across many physical devices. Hardware-assisted backends can further accelerate the data path while preserving the same guest-visible protocol.\n\nDirect device assignment gives a guest access to a physical device or device function. An input–output memory management unit translates and restricts the addresses used by device-initiated memory transfers, helping prevent a device assigned to one guest from accessing unrelated host memory. PCI Express Single Root I/O Virtualization, or SR-IOV, allows a supporting device to expose multiple lightweight virtual functions under a physical function. These virtual functions can be assigned separately, offering lower overhead than a fully software-mediated path.\n\nAccelerators introduce additional constraints. A graphics processing unit may be assigned exclusively, divided through hardware-supported partitions, or shared through a mediated software interface. These options differ in memory isolation, scheduling, supported features, and portability. Direct access can reduce overhead but tie a virtual machine closely to a particular device model, complicating migration and recovery. Device reset behavior, shared internal resources, and the ability to save execution state all influence whether an accelerator can be safely multiplexed or moved between hosts."
    },
    {
      "heading": "Storage virtualization and persistent state",
      "text": "Storage virtualization separates the storage interface used by a workload from the physical devices that hold its data. A guest commonly sees a virtual disk, while the host stores its contents in a file, a logical volume, a remote block device, or a distributed storage system. Beneath that representation, data may span multiple disks or machines. The virtual disk interface hides these details, allowing storage placement and hardware replacement without necessarily changing the guest’s view.\n\nTwo important image arrangements are fixed allocation and thin provisioning. A fully allocated virtual disk reserves its capacity in advance, whereas a thin-provisioned disk acquires physical backing as data is written. Thin provisioning improves utilization when nominal capacity exceeds actual use, but it does not create physical space. If the backing pool becomes full, writes can fail across multiple guests. Discard or trim operations can communicate that blocks are no longer needed, although reclamation depends on support throughout the storage stack.\n\nCopy-on-write enables efficient cloning and snapshotting. A base image can remain unchanged while each clone records modified blocks in a separate layer. Reads consult the relevant layers to find the latest version of a block. This makes it possible to create many similar environments without copying an entire operating-system image for each one. However, long chains of dependent images can increase lookup costs, complicate deletion, and create dependencies whose failure affects many descendants.\n\nA snapshot is a point-in-time representation, not automatically an independent backup. A disk snapshot may remain dependent on the original storage system, and a running guest may have unwritten data in memory. Crash-consistent snapshots resemble the state after sudden power loss; application-consistent snapshots coordinate with the guest and its applications to establish a more meaningful recovery point. For a database, this may require flushing logs, freezing writes briefly, or invoking application-specific mechanisms. Some virtual-machine snapshots also include processor and memory state, subject to device and platform limitations.\n\nStorage correctness depends on ordering and durability guarantees. A guest may issue a flush expecting previously acknowledged writes to survive failure. The virtual controller, image format, host file system, storage cache, and physical device must collectively honor that expectation. Misconfigured caching can make a system appear fast while weakening persistence guarantees. Encryption, replication, and deduplication can be inserted at several layers, but their placement changes what remains protected or shareable when images are copied, migrated, or restored."
    },
    {
      "heading": "Network virtualization",
      "text": "Network virtualization creates logical connectivity that is partly independent of physical cabling and switching. A virtual machine typically connects through a virtual network interface to a virtual switch on its host. That switch may connect guests to one another, to an external physical network, or to a restricted internal segment. Packets between two guests on the same host may never traverse a physical network adapter, making host-level forwarding and filtering important parts of the actual network.\n\nBasic virtual networking offers several connectivity models. Bridged networking places a guest on a network through the host’s physical interface, subject to the surrounding network’s configuration. Network address translation allows guests to share an outward-facing address while maintaining separate internal addresses. Host-only networks connect guests and the host without necessarily providing external access. These models describe reachability and addressing, not security guarantees: isolation also depends on forwarding rules, address validation, and the privileges of the host.\n\nLarger deployments use logical networks that span many machines. Overlay protocols such as VXLAN encapsulate tenant traffic inside packets carried by an underlying IP network. An overlay identifier distinguishes logical segments that can reuse the same address ranges. The physical underlay forwards encapsulated packets without needing to represent every tenant network directly. Encapsulation consumes header space and can affect the maximum transmission unit; mismatches can cause fragmentation or dropped traffic unless handled correctly.\n\nSoftware-defined networking separates network policy and control decisions from the mechanisms that forward packets. Controllers can program virtual switches, configure routing, and distribute filtering rules according to workload identity or deployment policy. Network virtualization and software-defined networking overlap but are not identical: a virtual network can exist without centralized control, and programmable networking can manage physical infrastructure. Network function virtualization is another related concept, replacing dedicated appliances with software implementations of functions such as firewalls, load balancers, and packet gateways.\n\nPerformance and visibility become more complicated when networks are layered. A packet may cross a guest interface, a virtual switch, an overlay tunnel, a physical adapter, and several external switches before reaching its destination. Offloads, multiple transmit queues, and direct device access can reduce host processor overhead but alter where traffic can be inspected. Troubleshooting therefore requires distinguishing logical topology from physical paths. Traffic capture at only one layer may omit encapsulated headers, offloaded processing, or communication that never leaves the host."
    },
    {
      "heading": "Containers and operating-system-level virtualization",
      "text": "Operating-system-level virtualization isolates groups of processes while allowing them to share one kernel. These isolated environments are commonly called containers. Unlike a conventional system virtual machine, a container does not boot an independent kernel with its own virtual processor and memory hardware. Instead, the host kernel presents selected processes with constrained views of system resources. This generally reduces startup time and per-instance overhead, but makes kernel sharing a defining feature of the isolation boundary.\n\nLinux containers combine several mechanisms. Namespaces provide separate views of resources such as process identifiers, mount points, network interfaces, and host names. Control groups account for and constrain resources, including processor time and memory. Capabilities divide traditional superuser authority into narrower privileges, while system-call filtering and mandatory access-control mechanisms can further restrict behavior. These controls solve different problems: hiding a process identifier does not limit processor consumption, and a memory limit does not prevent an otherwise permitted system call.\n\nContainer images package application files and user-space dependencies, often in reusable layers. The runtime constructs a root file system and starts processes with the requested isolation settings. The image may contain a distribution’s libraries and utilities without containing a separately running operating-system kernel. This explains both portability and its limits: a Linux container can carry its own user-space libraries, but still depends on compatible behavior from the host Linux kernel. Containers for a different kernel family generally require an additional virtual machine or compatibility mechanism.\n\nDocker, introduced in 2013, popularized an integrated workflow for building, distributing, and running container images. The Open Container Initiative subsequently established specifications for image formats and runtime behavior. Kubernetes provides orchestration for containerized workloads, including scheduling, service discovery, and desired-state reconciliation. Orchestration is distinct from the isolation mechanism itself: the same scheduler can coordinate workloads whose execution boundaries are implemented through different runtimes.\n\nContainers and virtual machines are often complementary. A cloud instance may be a virtual machine containing many containers; a container runtime may alternatively use lightweight virtual machines to strengthen separation. Conventional shared-kernel containers typically expose more host-kernel interaction than hardware virtual machines, but actual security depends on configuration and implementation. Privileged containers, host filesystem mounts, and access to runtime management interfaces can substantially weaken isolation. Conversely, a virtual machine with broad host integration or unsafe device access can also have a porous boundary."
    },
    {
      "heading": "Provisioning, snapshots, and migration",
      "text": "Virtual machines are manageable objects whose configuration and state can be created, copied, paused, moved, and destroyed through software. Provisioning normally begins with a machine definition and an image or installation source. The definition specifies virtual processors, memory, devices, firmware, and connectivity. Automated initialization can then provide machine identity, credentials, and application configuration. A reusable image is not a complete running instance: each instance also acquires mutable disks, network settings, execution state, and external dependencies.\n\nCloning requires special handling of identity. Duplicating a disk can also duplicate host names, security credentials, machine identifiers, or application-specific membership data. Generalized images therefore separate common software from per-instance information. Infrastructure management systems record intended configurations and reconcile them with running resources. The ability to create machines quickly does not remove administrative work; it changes that work toward image maintenance, configuration control, inventory, and automated lifecycle policies.\n\nLive migration moves a running virtual machine between hosts while attempting to keep interruption brief. In a common pre-copy method, the source continues running while memory pages are copied to the destination. Pages modified during copying are marked dirty and copied again. Finally, execution pauses while remaining state is transferred, after which the destination resumes the guest. If the guest modifies memory faster than it can be transferred, pre-copy may converge poorly, requiring throttling or a longer final pause.\n\nPost-copy migration reverses part of this sequence. Execution resumes at the destination before all memory has arrived, and missing pages are fetched from the source as required. This avoids repeatedly copying heavily modified pages but creates dependence on the migration path while state remains distributed. Failures during this interval can be harder to recover from. Hybrid approaches combine elements of both methods. Storage may be shared between hosts or migrated separately, and network mechanisms must preserve or reestablish the guest’s connectivity.\n\nMigration requires compatibility beyond matching processor brands. The destination must support the guest-visible processor features, device state, firmware expectations, and available resources. Directly assigned devices are especially challenging because their internal state may not be portable or fully capturable. High availability is a separate capability: restarting a failed guest on another host does not preserve uninterrupted execution. Continuous fault-tolerant execution requires additional replication and coordination mechanisms, while a snapshot or checkpoint captures state only at particular moments."
    },
    {
      "heading": "Performance, scheduling, and resource economics",
      "text": "Virtualization overhead is workload-dependent. Processor-intensive code that executes directly with few privileged transitions can run close to native speed, while workloads dominated by device emulation, address-translation misses, or frequent VM exits may experience larger penalties. A single overhead percentage is therefore not meaningful without identifying the hardware, software versions, configuration, and benchmark. Throughput, response-time distribution, startup latency, and resource efficiency can tell different stories about the same system.\n\nProcessor scheduling is a major source of variability. A guest scheduler assigns its processes to virtual CPUs, while the host scheduler assigns those virtual CPUs to physical execution resources. A guest can believe that a task is runnable even when its virtual CPU is not currently scheduled. Some systems expose this interval as steal time. Oversubscribing processors can improve average utilization, but excessive contention increases latency and makes performance less predictable, particularly for tightly coordinated parallel workloads.\n\nSynchronization can amplify scheduling effects. If a virtual CPU holding a lock is descheduled, other virtual CPUs may spend time waiting for a resource whose owner cannot currently progress. Hypervisor-aware locking and paravirtualized notifications can reduce this problem. Similar interactions occur with interrupts and timers: batching can reduce overhead, but delayed delivery can worsen latency. Real-time and low-latency workloads consequently place stronger constraints on processor reservation, interrupt routing, memory placement, and competing host activity.\n\nA simple capacity model illustrates both the benefit and the limit of consolidation. For a single resource, if simultaneously allocated demand is \\(D\\) and available capacity is \\(C\\), utilization is\n\n\\[U=\\frac{D}{C}.\\]\n\nThis ratio is only a starting point. Processor time, memory capacity, memory bandwidth, storage operations, and network bandwidth have different constraints, and a workload can saturate one while leaving others idle. Average demand also hides bursts. Admission control and capacity planning must account for correlated peaks and the reserve needed when a host fails.\n\nThe economic benefit of virtualization comes from pooling resources, automating operations, and reducing the coupling between workloads and individual machines. It can lower the number of underused servers and shorten deployment cycles. These gains are offset by management software, storage and network complexity, licensing arrangements, and the capacity required for resilience. Consolidation also enlarges failure domains: losing one heavily loaded host may affect many services. Energy savings likewise depend on actual consolidation and power management rather than following automatically from the creation of virtual machines."
    },
    {
      "heading": "Security boundaries and confidential computing",
      "text": "Virtualization can strengthen separation by placing workloads in distinct machine environments, but it does not make them intrinsically secure. The relevant threat model must identify which components are trusted: the guest kernel, hypervisor, device models, management services, host administrators, and physical hardware may have different roles. Traditional virtual machines generally protect guests from one another while trusting the host. A host administrator can normally inspect or alter ordinary guest memory and storage unless additional protections are used.\n\nA virtual-machine escape occurs when code in a guest gains unauthorized control outside its intended boundary, potentially through a vulnerability in a virtual device or other host-facing interface. Device emulation is security-sensitive because it processes inputs controlled by guest software. Reducing unnecessary virtual devices, isolating device-model processes, and limiting their privileges can reduce exposure, although they do not establish absolute isolation. Hypervisor management interfaces are equally important because legitimate administrative operations can already create, read, stop, or reconfigure machines.\n\nShared hardware introduces risks that do not require direct access to another guest’s memory. Cache state, branch prediction structures, memory deduplication, and timing behavior can expose information through side-channel attacks. Virtualization separates architectural state more readily than every microarchitectural effect. Mitigations may involve processor changes, firmware and operating-system updates, altered scheduling, or restrictions on resource sharing. Their costs and effectiveness depend on the specific attack mechanism.\n\nConfidential computing changes part of the traditional trust relationship by using hardware to protect workload data during execution. Technologies such as AMD SEV-SNP and Intel Trust Domain Extensions aim to isolate protected virtual-machine memory from components that would normally be highly privileged, including much of the host software stack. Hardware-backed attestation can provide evidence about a protected environment’s identity and measured configuration. Memory encryption alone is not equivalent to complete integrity protection or trustworthy execution; the guarantees depend on the architecture and protocol.\n\nProtected execution does not remove all external dependencies. A malicious or faulty host may still deny resources, interrupt execution, or interfere with input and output outside the protected boundary. Applications remain vulnerable to defects within the guest, compromised credentials, and unprotected endpoints. Migration, debugging, backup, and device access also require special handling when ordinary host software cannot freely inspect memory. Security analysis must therefore follow the entire data path rather than treating a virtual-machine boundary, or an encryption feature, as sufficient on its own."
    },
    {
      "heading": "Cloud infrastructure and large-scale management",
      "text": "Virtualization supplies the execution units of many infrastructure-as-a-service clouds. A customer requests a machine through an interface, and the provider maps that request to physical resources. The resulting service also includes identity management, network configuration, image catalogs, persistent storage, monitoring, and accounting. A collection of virtualized servers is not automatically a cloud: the service model depends on how resources are exposed, allocated, and operated.\n\nCloud systems commonly distinguish a control plane from a data plane. The control plane processes requests, maintains inventory, chooses placements, and records intended state. The data plane performs the actual workload execution, storage transfer, and packet forwarding. Failures in these planes have different consequences. An unavailable control service may prevent new machine creation while existing machines continue running; a failed compute host directly stops the workloads it contains. Robust management must also reconcile incomplete operations and disagreement between recorded and actual state.\n\nPlacement is a multidimensional scheduling problem. A host must have compatible processors, sufficient memory, appropriate networking, and access to required storage or accelerators. Policies may require related instances to run together for low latency or apart to reduce correlated failure. Availability zones and host groups express failure-domain assumptions rather than guarantees of uninterrupted service. Overcommitment, maintenance requirements, and expected demand all influence the scheduler’s decisions.\n\nMultitenancy allows independent customers or organizational groups to share infrastructure while maintaining separate administrative and execution environments. Isolation involves more than virtual-machine memory: quotas, image access, network policies, storage authorization, and management credentials must also remain separated. Some customers use dedicated hosts or dedicated instances to change their sharing arrangements. These options alter placement and resource exposure but do not eliminate dependence on provider management and physical infrastructure.\n\nServerless platforms and managed application services may conceal virtual machines from users while continuing to rely on them internally. Small, specialized virtual machines, often called microVMs, reduce device complexity and startup overhead for short-lived or densely packed workloads. Firecracker, released as open-source software in 2018, is an example of this design. At large scale, virtualization management increasingly focuses on immutable images, automated replacement, and declarative deployment rather than manual maintenance of long-lived machines. Persistent application state still requires explicit storage and recovery mechanisms outside the lifecycle of any disposable execution instance."
    },
    {
      "heading": "Desktop, development, and specialized applications",
      "text": "Desktop virtualization separates an interactive working environment from the user’s physical endpoint. In virtual desktop infrastructure, desktop operating systems run in centrally managed virtual machines, and users interact through a remote-display protocol. Session-based remote desktops are related but typically provide multiple user sessions within a shared operating-system instance. Application virtualization can instead package or redirect an individual application’s dependencies without presenting a complete remote desktop. These arrangements differ in isolation, compatibility, and the amount of state assigned to each user.\n\nInteractive performance depends on more than server processor speed. Display encoding, round-trip network latency, input handling, peripheral redirection, and graphics acceleration all affect the experience. A task involving text editing may tolerate conditions that make interactive three-dimensional graphics uncomfortable. Redirecting cameras, storage devices, or authentication hardware introduces additional compatibility and security questions. Centralization can simplify image deployment, but also makes network access and backend capacity central operational dependencies.\n\nSoftware development and testing use virtualization to create repeatable environments and test interactions among operating systems, libraries, and services. A snapshot can preserve a known state before an installation or destructive test, while templates can reproduce a machine configuration across a team. Automated build and continuous delivery systems often use disposable virtual machines or containers to reduce interference between jobs. Reproducibility nevertheless requires control over external package sources, clocks, randomness, credentials, and network services; a machine image alone does not freeze every dependency.\n\nSecurity research uses isolated environments to inspect malware and suspicious files. Virtual machines make it easier to restore state and observe system changes, but they are not inherently safe laboratories. Samples can recognize virtual hardware, change behavior, exploit shared integration features, or communicate with external systems. Research involving hostile software therefore depends on the complete containment arrangement, including networking and access to host resources, rather than merely on whether the sample runs inside a guest.\n\nCompatibility and preservation provide another important use. Virtual machines can keep older operating environments available after their original hardware is retired, while emulation can reproduce architectures that modern processors cannot execute directly. Scientific and industrial workloads may preserve validated software environments for long periods, although physical instruments, licensing systems, and timing-sensitive devices can remain difficult to reproduce. In telecommunications and embedded systems, virtualization can consolidate several functional environments on shared hardware, but strict timing and safety requirements constrain scheduling and resource sharing. Across these applications, portability remains conditional on the interface actually preserved: a disk image may be portable while a particular processor feature, accelerator, or external device is not."
    }
  ],
  "links": [
    "computer",
    "operating-system",
    "virtual-machine",
    "cloud-computing",
    "ibm",
    "linux",
    "emulation",
    "application-programming-interface",
    "virtual-memory",
    "kernel-operating-system",
    "non-uniform-memory-access",
    "device-driver",
    "graphics-processing-unit",
    "data-backup",
    "database",
    "file-system",
    "vxlan",
    "side-channel-attack",
    "malware"
  ],
  "sources": [],
  "license": "https://creativecommons.org/licenses/by/4.0/"
}