Memory resource management in VMware ESX server

Carl A. Waldspurger

article2002OSDI1,482 citationsBest Paper Award

Presents foundational memory virtualization techniques, including memory ballooning, content-based page sharing, and an idle memory tax, that enable hypervisors to safely and efficiently overcommit physical memory across unmodified guest operating systems.

Listen

Modern data centers face high operational costs and inefficient hardware usage due to underutilized physical servers. While consolidating multiple servers into virtual machines on a single physical host solves this underutilization, it introduces a major memory management challenge. Virtual machine monitors traditionally lack visibility into guest operating system memory usage, making it difficult to safely overcommit memory—assigning more total memory to virtual machines than physically exists—without causing severe performance degradation or double-paging anomalies.

The article demonstrates and evaluates novel memory resource management policies and mechanisms implemented in VMware ESX Server 1.5. Its main objective is to prove that standard, unmodified commodity operating systems such as Windows and Linux can efficiently share and dynamically overcommit physical memory while preserving performance isolation guarantees.

The authors designed a comprehensive memory management architecture and evaluated it through controlled synthetic benchmarks (such as dbench and SPEC95) and real-world multi-virtual-machine enterprise workloads on multi-processor hardware. The architecture introduces four core techniques: cooperative memory ballooning to reclaim memory via native guest operating system mechanisms, content-based page sharing to eliminate duplicate memory pages, statistical sampling combined with an idle memory tax to prevent inactive virtual machines from hoarding resources, and dynamic page remapping to reduce data-copying overhead for input/output devices.

The evaluation yielded several critical findings. First, content-based page sharing successfully reclaimed up to 67% of memory in homogeneous environments and between 7% and 33% of total memory in real-world production enterprise deployments without requiring guest operating system modifications. Second, the cooperative ballooning mechanism achieved memory reclamation with minimal overhead, tracking native performance within 1.4% to 4.4%. Third, applying an idle memory tax of 75% effectively reclaimed unneeded memory from idle virtual machines and reallocated it to active workloads, improving active application throughput by more than 30%. Finally, dynamic remapping of frequently accessed input/output pages across memory boundaries reduced costly buffer copying operations by several orders of magnitude.

These findings demonstrate that organizations can safely and aggressively consolidate enterprise server workloads onto fewer physical machines. By shifting memory reclamation decisions back to the guest operating systems through ballooning and reclaiming idle memory dynamically, systems can overcommit resources by 60% or more while maintaining strict quality-of-service guarantees. This substantially reduces hardware acquisition costs, floor space, and power consumption without sacrificing workload isolation or stability.

Organizations adopting server virtualization should configure proportional share allocations alongside minimum memory guarantees and utilize dynamic overcommitment policies with active idle taxation. For future operational development, virtualization platforms should expand dynamic remapping to optimize non-uniform memory access hardware, integrate cache-aware page allocations, and explore adaptive feedback mechanisms across combined processor and storage resources.

The results provide high confidence for standard server consolidation workloads running common operating systems. However, readers should note that memory savings from page sharing remain workload-dependent and will be lower in highly heterogeneous environments. Additionally, ballooning effectiveness depends on guest driver availability, requiring system-level swapping mechanisms as a temporary safety fallback during guest initialization or unexpected memory spikes.

Waldspurger (2002).pdf
  • Paper: Xen and the art of virtualization, P. Barham et al. (2003). Read this paper next to see how Xen introduced paravirtualization as an alternative approach to full virtualization, contrasting directly with VMware's transparent memory management techniques.
  • Paper: Live migration of virtual machines, Christopher J. Clark et al. (2005). This work builds on hypervisor memory tracking mechanisms to achieve live migration of running virtual machine memory states across physical hosts with minimal downtime.
  • Paper: Mesos: A Platform for Fine-Grained Resource Sharing in the Data Center, Benjamin Hindman et al. (2011). This paper scales the principles of dynamic resource multiplexing and overcommitment beyond single-host hypervisors to cluster-wide data center frameworks.
Cover for Memory resource management in VMware ESX server

Abstract

VMware ESX Server is a thin software layer designed to multiplex hardware resources efficiently among virtual machines running unmodified commodity operating systems. This paper introduces several novel ESX Server mechanisms and policies for managing memory. A ballooning technique reclaims the pages considered least valuable by the operating system running in a virtual machine. An idle memory tax achieves efficient memory utilization while maintaining performance isolation guarantees. Content-based page sharing and hot I/O page remapping exploit transparent page remapping to eliminate redundancy and reduce copying overheads. These techniques are combined to efficiently support virtual machine workloads that overcommit memory.

Table of Contents

  • 1 Introduction
  • 2 Memory Virtualization
  • 3 Reclamation Mechanisms
  • 3.1 Page Replacement Issues
  • 3.2 Ballooning
  • 3.3 Demand Paging
  • 4 Sharing Memory
  • 4.1 Transparent Page Sharing
  • 4.2 Content-Based Page Sharing
  • 4.3 Implementation
  • 5 Shares vs. Working Sets
  • 5.1 Share-Based Allocation
  • 5.2 Reclaiming Idle Memory
  • 5.3 Measuring Idle Memory
  • 5.4 Experimental Results
  • 6 Allocation Policies
  • 6.1 Parameters
  • 6.2 Admission Control
  • 6.3 Dynamic Reallocation
  • 7 I/O Page Remapping
  • 8 Related Work
  • 9 Conclusions
  • Acknowledgements
  • References

Knowls

  1. Knowl 1 — Ballooning Memory Reclamation Mechanism

    model/method

    Ballooning is a memory reclamation technique in virtualized systems that reclaims machine memory from a virtual machine (VM) by cooperating with the guest operating system's native memory management.

    A balloon module is loaded into the guest operating system as a pseudo-device driver or kernel service and communicates with the hypervisor (VMware ESX Server) through a private backchannel. Memory reclamation proceeds as follows:

    1. Inflation: When the hypervisor needs to reclaim memory, it sends a target allocation size to the balloon driver. The driver allocates pinned guest physical pages using native kernel allocation functions (such as get_free_page() in Linux or MmAllocatePagesForMdl() and MmProbeAndLockPages() in Windows). This allocation increases internal memory pressure in the guest OS, coaxing its native page replacement policy to reclaim pages from its free pool or page out least-valuable data to the guest's virtual swap disk.
    2. Reclamation: The balloon driver passes the physical page numbers (PPNs) of the allocated pages to the hypervisor. The hypervisor annotates its physical-to-machine mapping data structure (pmap), deallocates the backing machine page numbers (MPNs), and reallocates those machine pages to other VMs.
    3. Deflation: When the hypervisor returns memory to the VM, it instructs the balloon driver to deallocate its pinned pages, returning physical memory to the guest OS free pool.

    If the guest OS attempts to access a ballooned PPN (e.g., following a guest OS crash or reboot), the hypervisor intercepts the resulting fault, resets the balloon state ("pops" the balloon), and allocates a zeroed MPN to back the PPN just as on initial page access.

  2. Knowl 2 — Content-Based Transparent Page Sharing

    model/method

    Content-based page sharing identifies and consolidates identical memory pages across and within virtual machines without requiring modifications to the guest operating system or guest application code.

    The hypervisor scans guest pages and maintains a global hash table whose total metadata overhead is under 0.5%0.5\% of system memory:

    • Hashing: A 64-bit hash summarizes page contents. Hash table entries are compactly stored in 16-byte frames with collision chaining.
    • Hint Frames: When an unshared page is scanned, if no matching hash is found in the table, it is recorded as a hint frame containing a truncated hash, the VM identifier, and the guest physical page number (PPN). Crucially, the page is not marked copy-on-write (COW) at this stage, avoiding write faults on pages that may never find a match.
    • Verification and Sharing: When a candidate page's hash matches an existing hint frame, the hint page's contents are rehashed. If the hash remains valid, a full byte-by-byte comparison is performed. Upon a verified match, the candidate PPN and hint PPN are both mapped to a single machine page number (MPN) and marked copy-on-write (COW) in their shadow page tables, and the redundant MPN is returned to the free pool.
    • Shared Frames: A shared page is tracked with a shared frame containing the 64-bit hash, the shared MPN, and a 16-bit reference count. Pages with large reference counts (such as zero-filled pages) store extended counts in a separate overflow table. Any write attempt to a COW page triggers a minor fault, allocating a private copy for the writing VM.
  3. Knowl 3 — Proportional-Share Memory Allocation with Idle Memory Tax

    equation

    To prevent idle virtual machines with high share entitlements from hoarding memory unproductively while maintaining proportional-share isolation, min-funding revocation is extended with an idle memory tax rate τ∈[0,1)\tau \in [0, 1) and an estimated active memory fraction f∈[0,1]f \in [0, 1].

    The adjusted shares-per-page price ρ\rho for a virtual machine is defined as:

    ρ=SP⋅(f+k⋅(1−f))\rho = \frac{S}{P \cdot (f + k \cdot (1 - f))}

    where:

    • SS is the number of proportional shares assigned to the virtual machine (S>0S > 0).
    • PP is the number of physical pages currently allocated to the virtual machine (P>0P > 0).
    • ff is the fraction of allocated memory actively accessed by the VM during sampling (0≤f≤10 \le f \le 1).
    • τ\tau is the system-wide idle memory tax rate parameter (0≤τ<10 \le \tau < 1), configured by default to τ=0.75\tau = 0.75 (75%75\%).
    • kk is the idle page cost multiplier defined as:
    k=11−τk = \frac{1}{1 - \tau}

    The ratio ρ\rho represents the effective price the VM pays per page. When system memory is scarce, memory is revoked from the virtual machine with the lowest ρ\rho. Setting τ=0\tau = 0 (k=1k = 1) reduces the formula to pure share-based allocation ρ=S/P\rho = S / P. Setting τ→1\tau \to 1 (k→∞k \to \infty) allows all idle memory to be reclaimed by active virtual machines.

  4. Knowl 4 — Statistical Working-Set Estimation via Page Sampling

    algorithm

    ESX Server measures the active memory fraction ff of each virtual machine without guest OS modification by sampling guest memory pages over configurable execution-time sampling periods (defaulting to 30 seconds of VM execution time).

    Input: Total allocated pages P, sample size n (default 100 pages), sampling period T (default 30 seconds), prior fast moving average A_fast, prior slow moving average A_slow, filter gains g_fast and g_slow.
    Output: Active memory fraction estimate f, updated moving averages A_fast, A_slow.
    At start of sampling period T:
        Select n distinct PPNs uniformly at random from P.
        For each selected PPN:
            Invalidate cached translations in hardware TLB and shadow page tables.
        Reset touched page counter: t = 0.
    During sampling period T:
        On guest memory access fault to any of the n sampled PPNs:
            t = t + 1
            Re-establish valid shadow page table translation to allow subsequent accesses.
            Update intra-period fast average incrementally:
                A_current = g_fast * (t / n) + (1 - g_fast) * A_fast
    At end of sampling period T:
        Compute sample fraction: f_raw = t / n.
        Update slow moving average: A_slow = g_slow * f_raw + (1 - g_slow) * A_slow
        Update fast moving average: A_fast = g_fast * f_raw + (1 - g_fast) * A_fast
        Compute effective active fraction: f = max(A_slow, A_fast, A_current)
        return f, A_fast, A_slow

    Using the maximum of the fast, slow, and current averages ensures that the system reacts rapidly to sudden increases in memory usage while decaying gradually when memory becomes idle, avoiding premature revocation via the idle memory tax.

  5. Knowl 5 — Multi-Threshold Dynamic Memory Reallocation Policy

    model/method

    ESX Server dynamically drives free memory toward target levels using four reclamation thresholds that trigger progressively aggressive mechanisms:

    • high (default: 6%6\% of system memory): Free memory is sufficient; no active reclamation is performed. VM allocations are maintained to keep free memory above this threshold.
    • soft (default: 4%4\% of system memory): When free memory falls below 4%4\%, the hypervisor initiates memory reclamation using ballooning. Demand paging is used only if balloon drivers are unresponsive or absent.
    • hard (default: 2%2\% of system memory): When free memory drops below 2%2\%, the hypervisor forcibly reclaims memory by paging out VM pages to the hypervisor swap area on disk.
    • low (default: 1%1\% of system memory): When free memory drops below 1%1\%, the hypervisor continues paging to disk and blocks the execution of any VM that exceeds its target allocation.

    Hysteresis governs transitions: the system transitions to a more aggressive state immediately upon falling below a threshold, but transitions back to a higher state only after free memory exceeds the higher threshold by a safety margin.

  6. Knowl 6 — Memory Admission Control and Reservation Policy

    model/method

    Before allowing a virtual machine to power on, an admission control policy verifies that the physical host has sufficient unreserved machine memory and swap space to satisfy configured quality-of-service guarantees.

    Each VM is configured with three parameters:

    • min size: A guaranteed lower bound on machine memory allocation.
    • max size: The configured "physical" memory size presented to the guest OS.
    • shares: Proportional resource weights used during contention.

    Admission requires satisfying two reservation criteria:

    1. Machine Memory Reservation: Reserved Memory=min size+overhead\text{Reserved Memory} = \text{min size} + \text{overhead} where overhead accounts for hypervisor data structures, including pmap, shadow page tables, and VM frame buffers (typically 32 MB for standard VMs, with 4–8 MB for the frame buffer).
    2. Disk Swap Space Reservation: Reserved Swap=max size−min size\text{Reserved Swap} = \text{max size} - \text{min size} This disk space ensures the hypervisor can preserve guest state even under maximum overcommitment.
  7. Knowl 7 — Hot I/O Page Remapping

    model/method

    On systems with Intel Physical Address Extension (PAE) addressing up to 64 GB of physical memory, 32-bit DMA devices (e.g., standard PCI network adapters) can directly address only low memory below the 4 GB boundary. Accesses to high memory normally require copying data through temporary bounce buffers in low memory, introducing substantial CPU and latency overhead.

    ESX Server eliminates bounce-buffer copying by remapping pages:

    1. The hypervisor maintains copy statistics in a software cache of physical-to-machine page mappings (PPN-to-MPN) used for I/O operations (such as network packet transmits).
    2. When the copy count for a high-memory page exceeds a defined threshold, the page is classified as "hot" and the hypervisor transparently reallocates a low-memory MPN (< 4 GB) to back the guest PPN.
    3. The hypervisor updates shadow page tables to point to the new low-memory MPN, enabling future DMA operations on that page to execute directly without bounce-buffer copies.
  8. Knowl 8 — Content-Based Page Sharing Savings in Production Workloads

    data/table

    Memory savings achieved by content-based transparent page sharing were evaluated across three real-world production deployments running server workloads on VMware ESX Server:

    Deployment Guest Types Total MB Shared Reclaimed
    MB % MB %
    A 10 WinNT 2048 880 42.9% 673 32.9%
    B 9 Linux 1846 539 29.2% 345 18.7%
    C 5 Linux 1658 165 10.0% 120 7.2%

    The workloads represented distinct real-world operating environments:

    • Deployment A: Ten Windows NT 4.0 VMs at a Fortune 50 enterprise running databases (Oracle, SQL Server), web servers (IIS, WebSphere), and development services. Page sharing reclaimed 673 MB (32.9%32.9\% of total configured memory).
    • Deployment B: Nine Linux VMs at a nonprofit running Apache, Postfix, Majordomo, and IMAP servers, reclaiming 345 MB (18.7%18.7\%), of which 70 MB was zero-page sharing.
    • Deployment C: Five Linux VMs in VMware's IT department running Squid, Postfix, RAV, and SSH servers, reclaiming 120 MB (7.2%7.2\%), of which 25 MB was zero pages.
  9. Knowl 9 — Throughput and Overhead of Ballooning Memory Reclamation

    empirical result

    The execution overhead of memory ballooning was evaluated using the synthetic dbench file server benchmark running 40 clients on a single Red Hat Linux 7.2 virtual machine on a dual 800 MHz Pentium III system.

    Performance was measured comparing a VM booted natively with memory sizes between 128 MB and 256 MB against a VM booted with 256 MB and ballooned down to those same memory sizes:

    • When ballooned from 256 MB down to 128 MB (a 128 MB balloon), dbench throughput was 4.4%4.4\% lower than that of a VM booted natively with 128 MB.
    • As the balloon size decreased, this overhead dropped smoothly to 1.4%1.4\% at 224 MB (a 32 MB balloon).

    The minor throughput difference is attributable to guest kernel data structures that are dimensioned statically at boot time based on configured physical memory: a 256 MB guest boots with larger kernel tables, leaving slightly less free space when ballooned down than a machine booted with 128 MB.

  10. Knowl 10 — Performance Impact of Idle Memory Taxation Under Contention

    empirical result

    The effectiveness of the idle memory tax was demonstrated on an overcommitted ESX Server system with 512 MB physical RAM (360 MB available for VMs) running two VMs configured with equal shares and 256 MB maximum sizes (512 MB aggregate demand):

    • VM1 ran Windows 2000 Advanced Server and remained idle after booting.
    • VM2 ran Red Hat Linux 7.2 executing an active, memory-intensive dbench workload.

    With the idle tax rate set to τ=0%\tau = 0\% (pure proportional-share allocation), ESX Server allocated 179 MB to each VM equally, despite VM1 being completely idle. When the tax rate was increased to τ=75%\tau = 75\%, the hypervisor detected VM1's idleness via page sampling, reclaimed idle memory from VM1, and reallocated it to VM2. This rebalancing increased dbench execution throughput on VM2 by over 30%30\%.

  11. Knowl 11 — Operational Limitations of Ballooning and Demand Paging

    limitation

    Memory reclamation in virtual machine monitors via ballooning and meta-level paging has specific operational constraints:

    1. Ballooning Limitations:

      • Boot-Time Inactivity: The balloon driver does not operate while the guest operating system is booting and is ineffective if disabled, uninstalled, or unsupported by the guest kernel.
      • Transient Response Latency: Balloon inflation relies on guest OS process scheduling and memory management routines, which may not reclaim memory fast enough to absorb rapid aggregate memory surges.
      • Guest OS Allocation Limits: Guest operating systems impose upper limits on contiguous or driver-level memory allocations, capping the maximum size to which a balloon can expand.
    2. Demand Paging Limitations:

      • Double Paging: Meta-level swapping is transparent to the guest OS. If the hypervisor swaps out a guest physical page, and the memory-pressured guest OS subsequently chooses to write that same page to its virtual swap disk, the hypervisor must fault the page in from host swap only to write it out to guest swap.
      • Uninformed Page Selection: Hypervisors lack guest OS context regarding process priorities and page semantics, risking eviction of high-value working set pages when falling back to host paging.

Coverage note — Omitted specific graph details from the synthetic SPEC95 page sharing sweep (Figure 4) and time-series trace specifics of the 5-VM dynamic reallocation experiment (Figure 8) because their primary findings are fully subsumed by the production sharing table, the multi-threshold dynamic reallocation policy knowl, and the idle tax validation experiment.

References

  1. 1.Andrea C. Arpaci-Dusseau and Remzi H. Arpaci-Dusseau. “Information and Control in Gray-Box Systems,” Proc. Symposium on Operating System Principles, October 2001.
  2. 2.Ozalp Babaoglu and William Joy. “Converting a Swap-Based System to do Paging in an Architecture Lacking Page-Reference Bits,” Proc. Symposium on Operating System Principles, December 1981.
  3. 3.Edouard Bugnion, Scott Devine, Kinshuk Govil, and Mendel Rosenblum. “Disco: Running Commodity Operating Systems on Scalable Multiprocessors,” ACM Transactions on Computer Systems, 15(4), November 1997.
  4. 4.Pei Cao, Edward W. Felten, and Kai Li. “Implementation and Performance of Application-Controlled File Caching,” Proc. Symposium on Operating System Design and Implementation, November 1994.
  5. 5.Jeffrey S. Chase, Darrell C. Anderson, Prachi N. Thakar, and Amin M. Vahdat. “Managing Energy and Server Resources in Hosting Centers,” Proc. Symposium on Operating System Principles, October 2001.
  6. 6.R. J. Creasy. “The Origin of the VM/370 Time-Sharing System,” IBM Journal of Research and Development, 25(5), September 1981.
  7. 7.Bryan Ford, Mike Hibler, Jay Lepreau, Patrick Tullman, Godmar Back, and Stephen Clawson. “Microkernels Meet Recursive Virtual Machines,” Proc. Symposium on Operating System Design and Implementation, October 1996.
  8. 8.Robert P. Goldberg. “Survey of Virtual Machine Research,” IEEE Computer, 7(6), June 1974.
  9. 9.Kinshuk Govil, Dan Teodosiu, Yongqiang Huang, and Mendel Rosenblum. “Cellular Disco: Resource Management Using Virtual Clusters on Shared-Memory Multiprocessors,” Proc. Symposium on Operating System Principles, December 1999.
  10. 10.Peter H. Gum. “System/370 Extended Architecture: Facilities for Virtual Machines,” IBM Journal of Research and Development’, 27(6), November 1983.
  11. 11.Steven M. Hand. “Self-Paging in the Nemesis Operating System,” Proc. Symposium on Operating Systems Design and Implementation, February 1999.
  12. 12.Kieran Harty and David R. Cheriton. “Application-Controlled Physical Memory using External Page-Cache Management,” Proc. Fifth International Conference on Architectural Support for Programming Languages and Operating Systems, October 1992.
  13. 13.Intel Corporation. IA-32 Intel Architecture Software Developer’s Manual. Volumes I, II, and III, 2001.
  14. 14.Bob Jenkins. “Algorithm Alley,” Dr. Dobbs Journal, September 1997. Source code available from http://burtleburtle.net/bob/hash/
  15. 15.Ted Kaehler. “Virtual Memory for an Object-Oriented Language,” Byte, August 1981.
  16. 16.Minkyong Kim and Brian Noble. “Mobile Network Estimation,” Proc. Seventh Annual International Conference on Mobile Computing and Networking, July 2001.
  17. 17.Jochen Liedtke, Hermann Hartig, and Michael Hohmuth. “OS-Controlled Cache Predictability for Real-Time Systems,” Proc. Third IEEE Real-Time Technology and Applications Symposium, June 1997.
  18. 18.Marshall K. McKusick, Keith Bostic, Michael J. Karels, and John S. Quaterman. The Design and Implementation of the 4.4 BSD Operating System, Addison-Wesley, 1996.
  19. 19.Theodore H. Romer, Dennis Lee, Brian N. Bershad and J. Bradley Chen. “Dynamic Page Mapping Policies for Cache Conflict Resolution on Standard Hardware,” Proc. Symposium on Operating System Design and Implementation, November 1994.
  20. 20.L. H. Seawright and R. A. McKinnon. “VM/370: A Study of Multiplicity and Usefulness,” IBM Systems Journal, 18(1), 1979.
  21. 21.Timothy Sherwood, Brad Calder and Joel S. Emer. “Reducing Cache Misses Using Hardware and Software Page Placement,” Proc. International Conference on Supercomputing, June 1999.
  22. 22.David A. Solomon and Mark Russinovich. Inside Microsoft Windows 2000, Third Ed., Microsoft Press, 2001.
  23. 23.Jeremy Sugerman, Ganesh Venkitachalam, and Beng-Hong Lim. “Virtualizing I/O Devices on VMware Workstation’s Hosted Virtual Machine Monitor,” Proc. Usenix Annual Technical Conference, June 2001.
  24. 24.David G. Sullivan, Robert Haas, and Margo I. Seltzer. “Tickets and Currencies Revisited: Extensions to Multi-Resource Lottery Scheduling,” Proc. Seventh Workshop on Hot Topics in Operating Systems, March 1999.
  25. 25.David G. Sullivan and Margo I. Seltzer. “Isolation with Flexibility: A Resource Management Framework for Central Servers,” Proc. Usenix Annual Technical Conference, June 2000.
  26. 26.Andrew S. Tanenbaum. Modern Operating Systems, Prentice Hall, 1992.
  27. 27.R. Tremaine, P. Franaszek, J. Robinson, C. Schulz, T. Smith, M. Wazlowski, and P. Bland. “IBM Memory Expansion Technology (MXT),” IBM Journal of Research and Development’, 45(2), March 2001.
  28. 28.Andrew Tridgell. “dbench” benchmark. Available from ftp://samba.org/pub/tridge/dbench/, September 2001.
  29. 29.VMware, Inc. VMware ESX Server User’s Manual Version 1.5, Palo Alto, CA, April 2002.
  30. 30.Carl A. Waldspurger and William E. Weihl. “Lottery Scheduling: Flexible Proportional-Share Resource Management,” Proc. Symposium on Operating System Design and Implementation, November 1994.
  31. 31.Carl A. Waldspurger. Lottery and Stride Scheduling: Flexible Proportional-Share Resource Management, Ph.D. thesis, Technical Report MIT/LCS/TR-667, September 1995.
  32. 32.Carl A. Waldspurger and William E. Weihl. “An Object-Oriented Framework for Modular Resource Management,” Proc. Fifth Workshop on Object-Orientation in Operating Systems, October 1996.

Citation

MLA
Waldspurger, C. A. “Memory Resource Management in VMware ESX Server”. ACM SIGOPS Operating Systems Review, vol. 36, no. SI, 2002, pp. 181–94, https://doi.org/10.1145/844128.844146.
APA
Waldspurger, C. A. (2002). Memory resource management in VMware ESX server. ACM SIGOPS Operating Systems Review, 36(SI), 181–194. https://doi.org/10.1145/844128.844146
Chicago
Waldspurger, C. A. 2002. “Memory Resource Management in VMware ESX Server”. ACM SIGOPS Operating Systems Review 36 (SI): 181–94. https://doi.org/10.1145/844128.844146.
Harvard
Waldspurger, C.A. (2002) “Memory resource management in VMware ESX server”, ACM SIGOPS Operating Systems Review, 36(SI), pp. 181–194. Available at: https://doi.org/10.1145/844128.844146.
Vancouver
1. Waldspurger CA (2002) Memory resource management in VMware ESX server. ACM SIGOPS Operating Systems Review 36:181–194

BibTeX

@article{Waldspurger_2002, title={Memory resource management in VMware ESX server}, volume={36}, ISSN={0163-5980}, url={http://dx.doi.org/10.1145/844128.844146}, DOI={10.1145/844128.844146}, number={SI}, journal={ACM SIGOPS Operating Systems Review}, publisher={Association for Computing Machinery (ACM)}, author={Waldspurger, Carl A.}, year={2002}, month=Dec, pages={181–194} }
Metadata:Crossref

Access the Paper

This paper is available from its original source. Click below to access the PDF.

Open PDF