แแ แกแขแแขแแแจแ แแแกแแฃแแ แแแ vSphere-แจแ แจแแแแฎแแแแแแ แฌแแแแแแก แแแฎแกแแแ แแแแก (RAM) แจแแกแ แฃแแแแแก แแ แแชแฎแแแแแแแ.
แ แแแแ แช แฉแแแก, แแแฎแกแแแ แแแแ แงแแแแแคแแ แ แฃแคแ แ แแแแแแแ, แแแแ แ แแ แแชแแกแแ แแแ: แแฃ VM-แแ แแฃแจแแแแแก แแ แแแแแแแแ แฌแแ แแแแฅแแแแแ, แซแแแแแ แแ แจแแแแฉแแแ แแกแแแ. แแแแ แแ แแฃ แแกแแแ แแแแแฉแแแแแแแ, แแแแ แแ แฃแคแ แ แ แแฃแแแ แแแแแแ แแแแแแแแแแ. แแแแ แแ แแแ แแแ แ แแแจแ.
แชแแขแ แแแแ แแ
แแแ แขแฃแแแฃแ แ แแแแฅแแแแแแก แแแแ แแขแแฃแแ แแแฎแกแแแ แแแ แแฆแแแฃแแแ แกแแ แแแ แแก แแแฎแกแแแ แแแแแแ, แ แแแแแแแแแช แแฃแจแแแแก VM-แแแ. แแก แกแแแกแแแแ แแจแแแ แแ :). แแฃ แกแแ แแแ แแก แแแแ แแขแแฃแแ แแแฎแกแแแ แแแ แงแแแแแกแแแแก แกแแแแแ แแกแ แแ แแ แแก, ESXi แแฌแงแแแก แแแฎแกแแแ แแแแก แแแแแแ แแชแแแก แขแแฅแแแแแก แแแแแงแแแแแแก. แฌแแแแแฆแแแแ แจแแแแฎแแแแแจแ, VM แแแแ แแชแแฃแแ แกแแกแขแแแแแ แแแแจแแแแ RAM แฌแแแแแแก แจแแชแแแแแแแ.
ESXi แฌแงแแแขแก แ แแแแแ แขแแฅแแแแแก แแแแแงแแแแแแก RAM-แแก แแแขแแแ แแแแก แแแฎแแแแแ:
แแแฎแกแแแ แแแแก แกแขแแขแฃแกแ
แกแแแฆแแ แแก
แแฅแขแแฃแ แแแ
แแแฆแแแ
แแแแฃแก 400% แฃแคแแกแแ
แแแแ แแแแแขแแก แแแฆแฌแแแแก แจแแแแแ, แแแแ แแแฎแกแแแ แแแแก แแแแ แแแแ แแงแแคแ แแแขแแ แแแแ (TPS แแฃแจแแแแก แกแขแแแแแ แขแฃแ แ แแแแแจแ).
แฌแแแแแ
แแแแฃแก 100% แฃแคแแกแแ
แแแแ แแแฎแกแแแ แแแแก แแแแ แแแแ แแงแแคแ แแแขแแ แแแแ, TPS แแซแฃแแแแฃแแแ.
แ แแแแ
แแแแฃแก 64% แฃแคแแกแแ
TPS + Balloon
Hard
แแแแฃแก 32% แฃแคแแกแแ
TPS + แจแแแฃแแจแแ + แแแชแแแ
แแแแแแ
แแแแฃแก 16% แฃแคแแกแแ
แจแแแฃแแจแแ + แแแชแแแ + แแแแแแแแ
minFree แแ แแก แแแแ แแขแแฃแแ แแแฎแกแแแ แแแ, แ แแแแแแช แกแแญแแ แแ แฐแแแแ แแแแแ แแก แแฃแจแแแแแกแแแแก.
ESXi 4.1-แแแ แฉแแแแแแ, minFree แแแคแแฅแกแแ แแ แแแแฃแแแกแฎแแแแแ - แกแแ แแแ แแก แแแแ แแขแแฃแแ แแแฎแกแแแ แแแแก 6% (แแ แแชแแแขแแก แจแแชแแแ แจแแกแแซแแแแแแแ ESXi-แแ Mem.MinFreePct แแคแชแแแก แแแจแแแแแแ). แแแแแแแแแแแ แแแ แกแแแแจแ, แกแแ แแแ แแแแ แแแฎแกแแแ แแแแก แแ แแแก แแแแ, minFree แแแแฌแงแ แแแแแแแแ แฐแแกแขแแก แแแฎแกแแแ แแแแก แแแแแแแแก แกแแคแฃแซแแแแแ แแ แแ แ แ แแแแ แช แคแแฅแกแแ แแแฃแแ แแ แแชแแแขแฃแแ แแแแจแแแแแแแ.
minFree แแแแจแแแแแแแ (แแแแฃแแแกแฎแแแแ) แแแแแแแแแแแ แจแแแแแแแแแ แแ:
แแแฎแกแแแ แแแแก แแ แแชแแแขแ แแแชแฃแแแ minFree-แกแแแแก
แแแฎแกแแแ แแแแก แแแแแแแแแ
6%
0-4 GB
4%
4-12 GB
2%
12-28 GB
1%
แแแ แฉแแแแแ แแแฎแกแแแ แแแ
แแแแแแแแแ, แกแแ แแแ แแกแแแแก 128 GB แแแแ แแขแแฃแแ แแแฎแกแแแ แแแแ, MinFree แแแแจแแแแแแแ แแฅแแแแ แจแแแแแแ:
MinFree = 245,76 + 327,68 + 327,68 + 1024 = 1925,12 MB = 1,88 GB
แ แแแแฃแ แ แแแแจแแแแแแแ แจแแแซแแแแ แแแแกแฎแแแแแแแแแแก แ แแแแแแแแ แแกแแฃแแ แแ-แแ, แ แแช แแแแแแแแแแฃแแแ แกแแ แแแ แแ แแ RAM-แแ.
แแแฎแกแแแ แแแแก แแ แแชแแแขแ แแแชแฃแแแ minFree-แกแแแแก
แแแฎแกแแแ แแแแก แแแแแแแแแ
แฆแแ แแแฃแแแแ 128 GB
6%
0-4 GB
245,76 MB
4%
4-12 GB
327,68 MB
2%
12-28 GB
327,68 MB
1%
แแแ แฉแแแแแ แแแฎแกแแแ แแแ (100 GB)
1024 MB
แ แแแแ แช แฌแแกแ, แแ แแแฃแฅแขแแฃแแ แกแขแแแแแแแกแแแแก, แแฎแแแแ แแแฆแแแ แแแแแแแ แแแแ แจแแแซแแแแ แฉแแแแแแแแก แแแ แแแแฃแ แแ. แขแแกแขแแ แแแแกแ แแ แแแแแแแแ แแแแก แกแแแแแแแกแแแแก, Clear/Soft แแแแแแแ แแแแแแ แจแแแซแแแแ แแงแแก แแแกแแฆแแแ. แแฃ แฐแแกแขแแ แแแแ แแขแแฃแแ แแแฎแกแแแ แแแ 64%-แแ แแแแแแแแ MinFree, แแแจแแ แแแกแแ แแแแฃแจแแแ VM-แแแก แแแแแแแแแ แแฅแแ แแฃแจแแแแแก แแ แแแแแแแแ.
แแแแแแฃแ แกแแฎแแแแฌแแคแแจแ แแแแแแงแแแแแ แแแฎแกแแแ แแแแก แแฆแแแแแแก แแแ แแแแฃแแ แขแแฅแแแแ, แแแฌแงแแแฃแแ TPS-แแแ, แ แแแแแแช แแ แแฅแขแแแฃแแแ แแ แแแแแ แแแแแแแแก แแ แแฎแแแแก VM แแฃแจแแแแแแ, Swapping-แแแ. แแแ แจแแกแแฎแแ แฃแคแ แ แแแขแก แแแขแงแแแ.
แแแแ แแแก แแแแญแแแ แแแแ แแแแแแ แแแ (TPS). TPS แแ แแก, แฃแฎแแจแแ แ แแ แแแฅแแแ, แกแแ แแแ แแ แแแ แขแฃแแแฃแ แ แแแแฅแแแแแแก RAM แแแแ แแแแแก แแฃแแแแ แแแ.
ESXi แแซแแแก แแแแแขแฃแ แ แแแ แขแฃแแแฃแ แ แแแแฅแแแแก แแแแ แแขแแฃแแ แแแฎแกแแแ แแแแก แแแแ แแแแก แแแแ แแแแแก แฐแแจแแก แฏแแแแก แแแแแแแ แแ แจแแแแ แแแแก แแแแ แแ แจแแแก แแฃแแแแแแข แแแแ แแแแก, แแแแชแแแแแก แแแ แกแแ แแแ แแก แคแแแแแฃแ แแแฎแกแแแ แแแแจแ แแแแแ แแแแ แแแก แแแแแแแแแ. แจแแแแแแ, แคแแแแแฃแ แ แแแฎแกแแแ แแแแก แแแฎแแแ แแแ แแชแแ แแแแ แแ แแแฎแกแแแ แแแแก แญแแ แแ แแแแแฌแแ แ แจแแแซแแแแ แแแฆแฌแแฃแแ แแงแแก แแคแแฅแขแฃแ แแแแก แแแแแแแแก แแแ แแจแ.
แแก แแแฅแแแแแแ แแฃแจแแแแก แแฎแแแแ 4 KB แแแแแก แแแฎแกแแแ แแแแก แแแแ แแแแแ (แแแขแแ แ แแแแ แแแแแ). แฐแแแแ แแแแแ แ แแ แช แแ แชแแแแแแก 2 แแ แแแแแก แแแแ แแแแแก แแฃแแแแแแขแก (แแแแ แแแแ แแแแ): แแ แแแแแก แแแแแขแฃแ แ แแแแ แแแแแก แแแแแแก แจแแแกแ แแแแ แแ แแ แแก.
แแแแฃแแแกแฎแแแแแ, ESXi แแแแแงแแคแก แแแฎแกแแแ แแแแก แแแ แแแแ แแแแแ. แแแแ แแแแ แแแแแก แแแงแแคแ แแแขแแ แ แแแแ แแแแแ แแฌแงแแแ, แ แแแแกแแช แแแแฆแฌแแแ แแแฆแแแ แแแแแแแ แแแแแก แแแ แแแ แ แแ แแซแฃแแแแฃแแแ, แ แแแแกแแช แแแแฆแฌแแแ Clear แแแแแแแ แแแแ (แแฎ. แฐแแแแ แแแแแ แแก แแแแแแแ แแแแแก แชแฎแ แแแ).
แแฃ แแกแฃแ แ, แ แแ TPS-แแ แแแแฌแงแแก แแฃแจแแแแ แฐแแกแขแแก RAM-แแก แจแแแกแแแแก แแแแแแแแแก แแแ แแจแ, แแฅแแแ แฃแแแ แแแแงแแแแ แแแแจแแแแแแแ Advanced Options ESXi-แจแ. "Mem.AllocGuestLargePage" 0-แแแ (แแแแฃแแแกแฎแแแแ 1). แจแแแแแ แแแ แขแฃแแแฃแ แ แแแแฅแแแแแแกแแแแก แแแแ แแแฎแกแแแ แแแแก แแแแ แแแแแก แแแแแงแแคแ แแแแแ แแฃแแ แแฅแแแแ.
2014 แฌแแแก แแแแแแแ แแแแ, แงแแแแ ESXi แแแแแจแแแแแจแ, TPS VM-แแแก แจแแ แแก แแแแฃแแแกแฎแแแแแ แแแแแ แแฃแแแ, แ แแแแแ แแฆแแแฉแแแ แแแฃแชแแแแแแ, แ แแแแแแช แแแแ แแฃแแแ แกแแจแฃแแแแแแก แแซแแแแก แแ แ VM-แก แฌแแแแแ แแงแแก แกแฎแแ VM-แแก RAM-แแ. แแแขแแแแแ แแฅ. แแ แแ แจแแแฎแแแแ แแ แแแคแแ แแแชแแ TPS แแแฃแชแแแแแแแก แแแแแงแแแแแแก แแ แแฅแขแแแฃแแ แแแแฎแแ แชแแแแแแแก แจแแกแแฎแแ.
TPS แแแแแขแแแ แแแแขแ แแแแแแ แแแคแแ แแแแแฃแแ แแแ แแแแขแแก แแแจแแแแแแ "Mem.ShareForceSalting" ESXi-แแ:
0 - Inter-VM TPS. TPS แแฃแจแแแแก แกแฎแแแแแกแฎแแ VM-แแแแก แแแแ แแแแแ;
1 โ TPS VM-แแแแกแแแแก แแแแแ โsched.mem.pshare.saltโ แแแแจแแแแแแแแ VMX-แจแ;
2 (แแแแฃแแแกแฎแแแแ) โ Intra-VM TPS. TPS แแฃแจแแแแก แแแแ แแแแแ VM-แจแ.
แแแแแแแแแ แแแ แ แแฅแแก แแแแ แแแแ แแแแแก แแแแแ แแแแก แแ Inter-VM TPS-แแก แฉแแ แแแแก แกแแขแแกแขแ แกแแแแแแแ. แแก แแกแแแ แจแแแซแแแแ แแแแแงแแแแแฃแ แแฅแแแก แกแขแแแแแแแกแแแแก แแแแ แ แแแแแแแแแ แแกแแแแกแ VM-แแแแ. แแแแแแแแแ, แกแขแแแแแแแ VDI-แแ, แคแแแแแฃแ แแแฎแกแแแ แแแแจแ แแแแแแแแ แจแแแซแแแแ แแแแฆแฌแแแก แแแแฃแ แแ แแชแแแขแก.
แแแฎแกแแแ แแแแก แแฃแ แแแ แแแคแ แแแ. Balooning แแฆแแ แแ แแก แแกแแแ แฃแแแแแแแ แแ แแแแญแแแ แแแแ แขแแฅแแแแ VM แแแแ แแชแแฃแแ แกแแกแขแแแแกแแแแก, แ แแแแ แช TPS. แแแแ แแ แแฃ แกแฌแแ แแ แแแแแแงแแแแแ, แจแแแแซแแแแ แแชแฎแแแ แแ แแ แแแฃแจแแแ Balloning-แแ.
Vmware Tools-แแแ แแ แแแ VM-แแ แแแแแแขแแแแแฃแแแ แกแแแชแแแแฃแ แ แแ แแแแแ แ, แกแแฎแแแฌแแแแแแ Balloon Driver (aka vmmemctl). แ แแแแกแแช แฐแแแแ แแแแแ แ แแฌแงแแแก แคแแแแแฃแ แ แแแฎแกแแแ แแแแก แแแแฌแฃแ แแแก แแ แจแแแแก Soft แแแแแแแ แแแแแจแ, ESXi แกแแฎแแแก VM-แก แแแแแฃแงแแแแแแแ แแแแ แแขแแฃแแ แแแฎแกแแแ แแแแก แแฆแแแแแ แแ Balloon Driver-แแก แแแจแแแแแแ. แแ แแแแแ แ, แแแแแก แแฎแ แแ, แแฃแจแแแแก แแแแ แแชแแฃแแ แกแแกแขแแแแก แแแแแแ แแ แแแฎแแแก แแแกแแแ แแแแแกแฃแคแแ แแแฎแกแแแ แแแแก. แฐแแแแ แแแแแ แ แฎแแแแแก แคแแแแแฃแ แ แแแฎแกแแแ แแแแก แ แแแแ แแแแ แแแแก แแฅแแก แแแแแแแแฃแแ Balloon Driver, แแฆแแแก แแแฎแกแแแ แแแแก แแแ แขแฃแแแฃแ แ แแแแฅแแแแแแ แแ แฃแแ แฃแแแแก แแแก แฐแแกแขแก. OS-แแก แแฃแจแแแแแกแแแ แแแแแแจแแ แแแแ แแ แแแแแ แ แแ แแแแแแ แแ แแ แแก, แ แแแแแ OS แแแแแแ แแแฎแกแแแ แแแ แแแฃแแแ แแแฃแแแ Balloon Driver-แแก แแแแ . แแแแฃแแแกแฎแแแแแ, Balloon Driver-แก แจแแฃแซแแแ แแแแแแแแก VM แแแฎแกแแแ แแแแก 65%-แแแ.
แแฃ VMware Tools แแ แแ แแก แแแแแกแขแแแแ แแแฃแแ VM-แแ แแ Balloning แแแแแ แแฃแแแ (แแ แแแแก แแ แแแ แฉแแแ, แแแแ แแ แแ แแก
Balloon Driver-แแก แแฃแจแแแแแก แจแแแแฌแแแแ แจแแกแแซแแแแแแแ OS-แแแ VMware Tools-แแก แกแแจแฃแแแแแแ.
แแแฎแกแแแ แแแแก แจแแแฃแแจแแ. แแก แขแแฅแแแแ แแแแแแงแแแแแ, แ แแแแกแแช ESXi แแฆแฌแแแก แแซแแแ แแแแแแแ แแแแแก. แ แแแแ แช แกแแฎแแแ แแแแแแแแแแก, ESXi แชแแแแแแก แจแแแฃแแจแแก แแแแ แแขแแฃแแ แแแฎแกแแแ แแแแก 4KB แแแแ แแ 2KB-แจแ, แ แแแแช แแแแแแกแฃแคแแแแก แแแ แแแแฃแ แแแแแแก แกแแ แแแ แแก แคแแแแแฃแ แแแฎแกแแแ แแแแจแ. แแก แขแแฅแแแแ แแแแจแแแแแแแแแ แแ แแแก VM RAM แแแแ แแแแแก แจแแแแแ แกแแ แฌแแแแแแก แแ แแก, แ แแแแแ แแแแ แแ แฏแแ แฃแแแ แแงแแก แแแแแแแ แแกแแฃแแ. แแแแฏแแ แงแแแแ แแแแ แแแก แจแแแฃแแจแแ แจแแฃแซแแแแแแแ แแ แแแแแ แแ แแชแแกแก แแแ แแแแฃแแ แแ แ แกแญแแ แแแแ. แแแแขแแ, แแก แขแแฅแแแแ แแ แแฅแขแแแแจแ แแ แช แแฃ แแกแ แแคแแฅแขแฃแ แแ.
แแแฎแกแแแ แแแแก แแแชแแแ. แแแฎแกแแแ แแแแก แจแแแฃแแจแแแก แฎแแแแแแแ แคแแแแก แจแแแแแ, ESXi แแแแฅแแแก แแแ แแแฃแแแแ (แแฃ VM แแ แแแแแแแแ แกแฎแแ แฐแแกแขแแแแ แแ แแ แแ แแก แแแแแ แแฃแแ) แแแแแแแก Swapping-แแ. แแ แแฃ แแแ แฉแ แซแแแแแ แชแแขแ แแแฎแกแแแ แแแ (แแแแแแ แแแแแแแ แแแแ), แแแจแแ แฐแแแแ แแแแแ แ แแกแแแ แฌแงแแแขแก แแแฎแกแแแ แแแแก แแแแ แแแแแก แแแแแงแแคแแก VM-แแ, แ แแแแช แจแแแซแแแแ แแแแแแฌแแแแก แแ แแแแแแแแ VM-แแก แกแขแฃแแ แแก OS-แจแ.
แแกแ แแฃแจแแแแก Swapping. แ แแแแกแแช แฉแแ แแแแ แแแ แขแฃแแแฃแ แแแแฅแแแแก, แแแกแแแแก แแฅแแแแแ แคแแแแ .vswp แแแคแแ แแแแแแ. แแก แแแแแ แฃแแ แแก VM-แแก แแ แแ แแแแ แแแ แแแฃแแ แแแแ แแขแแฃแแ แแแฎแกแแแ แแแแก: แแก แแ แแก แแแแกแฎแแแแแแ แแแแคแแแฃแ แแ แแแฃแ แแ แ แแแแ แแแ แแแฃแ แแแฎแกแแแ แแแแก แจแแ แแก. แ แแแแกแแช Swapping แแฃแจแแแแก, ESXi แชแแแแก แแแ แขแฃแแแฃแ แ แแแแฅแแแแก แแแฎแกแแแ แแแแก แแแแ แแแแก แแ แคแแแแจแ แแ แแฌแงแแแก แแแกแแแ แแฃแจแแแแแก แกแแ แแแ แแก แคแแแแแฃแ แ แแแฎแกแแแ แแแแก แแแชแแแแ. แ แ แแฅแแ แฃแแแ, แแกแแแ "RAM" แแแฎแกแแแ แแแ แ แแแแแแแแ แ แแแแ แแแแแ แแแแ แ แ แแแแฃแ แแแฎแกแแแ แแแแจแ, แแแจแแแแช แแ, แแฃ .vswp แแ แแก แกแฌแ แแค แจแแแแฎแแแแ.
Balooning-แแกแแแ แแแแกแฎแแแแแแแ, แ แแแแกแแช แแแแแฃแงแแแแแแแ แแแแ แแแแ แแฆแแแฃแแแ VM-แแแ, Swapping แแแแ แแแแ, แ แแแแแแกแแช แแฅแขแแฃแ แแ แแงแแแแแแ OS แแ VM-แแก แจแแแแแ แแ แกแแแฃแแ แแแแแแแชแแแแ, แจแแแซแแแแ แแแแแแแแแก แแแกแแแ. แจแแแแแแ, VM-แแก แจแแกแ แฃแแแแ แแแแแแก แแแงแแแแแแแ. VM แคแแ แแแแฃแ แแ แแฃแจแแแแก แแ, แแแแแแฃแ, แจแแแซแแแแ แกแฌแแ แแ แแแแแ แแแ OS-แแแ. แแฃ แแแแแแแแแ แแแฅแแ ๐
แแฃ VM-แแแ แฌแแแแแแแ Swap-แแ, แแก แแ แแก แแแแแฃแแแแแแ แกแแขแฃแแชแแ, แ แแแแแก แแแแแแแ แแชแแแแแ แฃแแฏแแแแกแแ, แแฃ แแก แจแแกแแซแแแแแแแ.
แซแแ แแแแแ แแแ แขแฃแแแฃแ แ แแแแฅแแแแแแก แแแฎแกแแแ แแแแก แแฃแจแแแแแก แแ แแชแฎแแแแแแ
แแกแ แ แแ แแแแแแแ แแแแแแ แแ. VM-แแก แแแฎแกแแแ แแแแก แแแแแแแ แแแแแก แแแแแขแแ แแแแแกแแแแก แแ แแก แจแแแแแแ แแ แแชแฎแแแแแแ:
แแฅแขแแฃแ แ โ แแฉแแแแแแก แแแแ แแขแแฃแแ แแแฎแกแแแ แแแแก แ แแแแแแแแแก (KB), แ แแแแแแแแแช แฌแแแแแ แแงแ VM แฌแแแ แแแแแแแแก แแแ แแแแจแ.
แแแแแงแแแแแ - แแแแแแ แ แแช แแฅแขแแฃแ แ, แแแแ แแ VM-แแก แแแแคแแแฃแ แแ แแแฃแแ แแแแ แแขแแฃแแ แแแฎแกแแแ แแแแก แแ แแชแแแขแฃแแแ. แแแแแแแแแแแ แจแแแแแแ แคแแ แแฃแแแก แแแแแงแแแแแแ: แแฅแขแแฃแ แ รท แแแ แขแฃแแแฃแ แ แแแแฅแแแแก แแแแคแแแฃแ แแ แแแฃแแ แแแฎแกแแแ แแแแก แแแแ.
แแแฆแแแ แแแแแงแแแแแ แแ แแฅแขแแฃแ แ, แจแแกแแแแแแกแแ, แงแแแแแแแแก แแ แแ แแก VM แแฃแจแแแแแก แแ แแแแแแแแแก แแแฉแแแแแแแแ. แแฃ VM แแแ แแกแแฃแแแ แแงแแแแแก แแแฎแกแแแ แแแแก (แงแแแแ แจแแแแฎแแแแแจแ, แแแกแแ แฌแแแแแ แแฅแแก), แแก แแ แแแจแแแแก, แ แแ แแแฎแกแแแ แแแ แแ แแ แแก แกแแแแแ แแกแ. แแแ แแฅแแ, แแก แแ แแก แแแแแแ, แ แแ แแแแแแฎแแแแ แ แ แฎแแแแ OS-แจแ.
แแ แกแแแแแก แกแขแแแแแ แขแฃแแ แกแแแแแแแแแชแแ แแแฎแกแแแ แแแแก แแแแแงแแแแแแกแแแแก VM-แแแแกแแแแก:
แแแแแแแ แ - VM แแแแ แแขแแฃแแ แแแฎแกแแแ แแแแก แ แแแแแแแแ, แ แแแแแแช แแแแฆแแแฃแแแ TPS-แแก แแแแแงแแแแแแ (VM-แจแ แแ VM-แแแก แจแแ แแก).
แแแชแแแฃแแ - แฐแแกแขแแก แคแแแแแฃแ แ แแแฎแกแแแ แแแแก แ แแแแแแแแ (KB), แ แแแแแแช แแแแแงแแคแแแ แแงแ VM-แแ. แ แแแแก แแแแแแ แแแแก.
แแแฎแแแ แแแฃแแ (Granted - Shared) - แคแแแแแฃแ แ แแแฎแกแแแ แแแแก แ แแแแแแแแ (KB), แ แแแแแกแแช VM แแแแฎแแแ แก แฐแแกแขแแกแแแ. แแ แจแแแชแแแก แแแแแแ แแแฃแแก.
แแฃ VM แแแฎแกแแแ แแแแก แแแฌแแแ แแแชแแแฃแแแ แแ แ แฐแแกแขแแก แคแแแแแฃแ แ แแแฎแกแแแ แแแแแแ, แแ แแแแ แกแแแ แคแแแแแแแ, แแ แแแฎแกแแแ แแแ แแฆแแแฃแแแ VM-แแแ Balloon Driver-แแก แแแจแแแแแแ, แแก แแแแฎแ แแ แแ แแก แแแแแแแแกแฌแแแแแฃแแ แแแชแแแฃแแ แแ แแแฎแแแ แแแฃแแ.
แแแฆแแแ แแแแแญแแแฃแแ แแ แแแฎแแแ แแแฃแแ แฆแแ แแแฃแแแแแแ แกแ แฃแแแแ แแแ แแแแฃแ แแ. แแแแ แแชแแฃแแ แกแแกแขแแแ แแแแแแแแ แแฆแแแก แแแฎแกแแแ แแแแก แฐแแแแ แแแแแ แแกแแแ แแ แแ แแแ แฃแแแแก แแแก. แแ แแแ แแแแแแแแแแแจแ, แแฅแขแแฃแ แแ แแแจแแแแฃแ VM-แจแ, แแ แแ แแชแฎแแแแแแแก แแแแจแแแแแแแแแ แฃแแฎแแแแแแแ แแแแคแแแฃแ แแ แแแฃแแ แแแฎแกแแแ แแแแก แ แแแแแแแแแก แแ แ แฉแแแ แแฅ.
Zero โ VM RAM-แแก แ แแแแแแแแ (KB), แ แแแแแแช แจแแแชแแแก แแฃแแแแก. แแกแแแ แแแฎแกแแแ แแแ แฐแแแแ แแแแแ แแก แแแแ แแแแแฎแแแแแ แแแแแกแฃแคแแแ แแ แจแแแซแแแแ แแแแชแแก แกแฎแแ แแแ แขแฃแแแฃแ แแแแฅแแแแแก. แแแก แจแแแแแ, แ แแช แกแขแฃแแแ แ OS แแแฌแแ แก แ แแแแแก แแฃแแแแแ แแแฎแกแแแ แแแแจแ, แแก แแแแแแแก Consumed-แจแ แแ แแ แแ แฃแแแแแ แฃแแแ.
แ แแแแ แแแ แแแฃแแ แแแแแแแแแ โ VM RAM-แแก แแแแแแแ, (KB) แฐแแแแ แแแแแ แแก แแแแ แ แแแแ แแแ แแแฃแแ VM แแแแ แแชแแแกแแแแก. แแก แแชแแ แ แแแแฎแแ, แแแแ แแ แแก แฎแแแแแกแแฌแแแแแ แฃแแแ แแงแแก แฐแแกแขแแ, แฌแแแแแฆแแแแ แจแแแแฎแแแแแจแ VM แแ แแแแฌแงแแแ.
Balloon โ แแแแ แแขแแฃแแ แแแฎแกแแแ แแแแก แ แแแแแแแแ (KB) แแแแฆแแแฃแแ VM-แแแ Balloon Driver-แแก แแแแแงแแแแแแ.
แจแแแฃแแจแฃแแ - แจแแแฃแแจแฃแแ แแแแ แแขแแฃแแ แแแฎแกแแแ แแแแก แ แแแแแแแแ (KB).
แแแแแชแแแแแก โ แแแแ แแขแแฃแแ แแแฎแกแแแ แแแแก แ แแแแแแแแ (KB), แ แแแแแแช แกแแ แแแ แแ แคแแแแแฃแ แ แแแฎแกแแแ แแแแก แแแแแแแแแแก แแแแ แแแแแแแแ แแแกแแแ.
แแฃแจแขแแแแกแ แแ แแแฎแกแแแ แแแแก แแฆแแแแแแก แกแฎแแ แขแแฅแแแแแก แแ แแชแฎแแแแแแ แแฃแแแก แขแแแแ.
แแกแ แแแแแแงแฃแ แแแ แแ แแคแแแ แแแ แแแแฃแ แแ แแแแฃแจแแแ VM-แแก แแแฎแกแแแ แแแแก แแ แแชแฎแแแแแแแ 150 GB แแแแ แแขแแฃแแ แแแฎแกแแแ แแแแ.
แฅแแแแแ แแแชแแแฃแ แแ แแคแแแจแ VM-แก แแจแแแ แ แแ แแแแแแแแ แแฅแแก. แแ แแคแแแแก แฅแแแแแ แฎแแแแแ, แ แแ แแ VM-แกแแแแก แแแแแงแแแแแฃแแแ RAM-แแแ แแฃแจแแแแแก แงแแแแ แแฆแฌแแ แแแ แขแแฅแแแแ. แแฃแจแขแ แแ VM-แแกแแแแก แแแชแแแแแแ แแแแแ แแแแ แ แแแฎแแแ แแแฃแแ. แกแแแแแแแแแแจแ, VM แฃแคแ แ แแแแแแ แแ, แแแแ แ แชแแชแฎแแแ.
ESXTOP
แ แแแแ แช CPU-แก แจแแแแฎแแแแแจแ, แแฃ แแแกแฃแ แก แกแฌแ แแคแแ แจแแแแคแแกแแ แกแแขแฃแแชแแ แฐแแกแขแแ, แแกแแแ แ แแแแ แช แแแกแ แแแแแแแแ 2 แฌแแแแแแ แแแขแแ แแแแแ, แฃแแแ แแแแแแแงแแแแ ESXTOP.
ESXTOP แแแฎแกแแแ แแแแก แแแ แแแ แแแแแแซแแฎแแแ "m" แฆแแแแแแ แแ แแกแ แแแแแแงแฃแ แแแ (แแ แฉแแฃแแแ แแแแแแ B,D,H,J,K,L,O):
แฉแแแแแแแก แกแแแแขแแ แแกแ แแฅแแแแ แจแแแแแแ แแแ แแแแขแ แแแ:
Mem overcommit แกแแจ โ แแแฎแกแแแ แแแแก แแแแแญแแ แแแแฃแแ แแแแแฌแแ แแก แกแแจแฃแแแ แแแแจแแแแแแแ แฐแแกแขแแ 1, 5 แแ 15 แฌแฃแแแก แแแแแแแแแแแจแ. แแฃ แแก แแฃแแแ แแแฆแแ แแแแก, แแแจแแ แแก แแ แแก แแแแก แแแแแแ, แ แแ แแแแแแฎแแแแ แ แ แฎแแแแ, แแแแ แแ แแ แ แงแแแแแแแแก แแ แแแแแแแแแก แแแฉแแแแแแแแ.
แฎแแแแแจแ PMEM/MB ะธ VMKMEM/MB โ แแแคแแ แแแชแแ แกแแ แแแ แแก แคแแแแแฃแ แ แแแฎแกแแแ แแแแก แแ VMkernel-แแกแแแแก แฎแแแแแกแแฌแแแแแ แแแฎแกแแแ แแแแก แจแแกแแฎแแ. แแฅ แกแแแแขแแ แแกแ แแแแแแแก แจแแ แแก แจแแแแซแแแแ แแแฎแแ minfree แแแแจแแแแแแแ (MB-แจแ), แแแกแแแแซแแแ แแแแแแแ แแแแ แแแฎแกแแแ แแแแจแ (แฉแแแแก แจแแแแฎแแแแแจแ แแแฆแแแ).
แฒฎแแแจแ NUMA/MB แแฅแแแ แจแแแแซแแแแ แแแฎแแ RAM-แแก แแแแแฌแแแแแ NUMA แแแแแซแแแจแ (แกแแแแขแแแจแ). แแ แแแแแแแแจแ แแแแแฌแแแแแ แแ แแแแแแแแ แแ, แ แแช แแ แแแชแแแจแ แแ แช แแฃ แแกแ แแแ แแแ.
แฅแแแแแ แแแชแแแฃแแแ แกแแ แแแ แแก แแแแแแ แกแขแแขแแกแขแแแ แแแฎแกแแแ แแแแก แแฆแแแแแแก แขแแฅแแแแแกแแแแก:
PSHARE/MB โ แแก แแ แแก TPS แกแขแแขแแกแขแแแ;
SWAP/MB โ แกแแแ แแแแแงแแแแแแก แกแขแแขแแกแขแแแ;
ZIP/MB โ แแแฎแกแแแ แแแแก แแแแ แแแก แจแแแฃแแจแแแก แกแขแแขแแกแขแแแ;
MEMCTL/MB โ Balloon Driver-แแก แแแแแงแแแแแแก แกแขแแขแแกแขแแแ.
แแแแแแแแฃแแแฃแ แ VM-แแแแกแแแแก แจแแแซแแแแ แแแแแแขแแ แแกแแแ แจแแแแแแ แแแคแแ แแแชแแ. แแแ-แแแแก แกแแฎแแแแแ แแแแแแแ, แ แแ แแแงแฃแ แแแแแ แแ แแแแแแฃแแแงแ :). แแฃ ESXTOP แแแขแ แแแ แแกแแแแกแแ vSphere-แแก แแ แแชแฎแแแแแก, แแ แแแแแฌแแแแ แจแแกแแแแแแก แแ แแชแฎแแแแก.
MEMSZ - VM-แแ แแแแคแแแฃแ แแ แแแฃแแ แแแฎแกแแแ แแแแก แ แแแแแแแแ (MB).
MEMSZ = GRANT + MCTLSZ + SWCUR + แฎแแแฃแฎแแแแแแ.
แแ แแแขแ - แแแแแญแแแฃแแ MB-แจแ.
TCHD โ แแฅแขแแฃแ แแ MByte-แจแ.
MCTL? โ แแแแแแขแแแแแฃแแแ แแฃ แแ แ Balloon Driver VM-แแ.
MCTLSZ โ แแฃแจแขแ MB-แแแ.
MCTLGT โ แแแแ แแขแแฃแแ แแแฎแกแแแ แแแแก แ แแแแแแแแ (MBytes), แ แแแแแแช ESXi-แก แกแฃแ แก แแแแแฆแแก VM-แแแ Balloon Driver-แแก แแแจแแแแแแ (Memctl Target).
MCTLMAX - แแแแ แแขแแฃแแ แแแฎแกแแแ แแแแก แแแฅแกแแแแแฃแ แ แ แแแแแแแแ (แแแแแขแ), แ แแแแแแช ESXi-แก แจแแฃแซแแแ แแแแแฆแแก VM-แแแ Balloon Driver-แแก แแแจแแแแแแ.
SWCUR โ Swap แคแแแแแแแ VM-แแกแแแแก แแแแแงแแคแแแ แแแแ แแขแแฃแแ แแแฎแกแแแ แแแแก แแแแแแแแ แ แ แแแแแแแแ (MBytes).
S.W.G.T. โ แแแแ แแขแแฃแแ แแแฎแกแแแ แแแแก แ แแแแแแแแ (แแแแแขแ), แ แแแแแแช ESXi-แก แกแฃแ แก แแแแแกแชแแก VM-แก Swap แคแแแแแแแ (Swap Target).
แแฅแแแ แแกแแแ แจแแแแซแแแแ แแแฎแแ แฃแคแ แ แแแขแแแฃแ แ แแแคแแ แแแชแแ VM-แแก NUMA แขแแแแแแแแแก แจแแกแแฎแแ ESXTOP-แแก แกแแจแฃแแแแแแ. แแแแกแแแแแก แแแ แฉแแแ แแแแแแ D, G:
แฒแฒแฒขแฒแฒ แฒ โ NUMA แแแแแซแ, แ แแแแแแแแแช แแแแแแ แแแแก VM. แแฅ แจแแแแซแแแแ แแแฃแงแแแแแแแแ แจแแแแฉแแแแ แคแแ แแ vm, แ แแแแแแช แแ แฏแแแแ แแ แ NUMA แแแแแซแแ.
NRMEM - แ แแแแแ แแแแแแแแขแก แแฆแแแก VM แแแกแขแแแชแแฃแ แ NUMA แแแแแซแแแแ.
NLMEM - แ แแแแแ แแแแแแแแขแก แแฆแแแก VM แแแแแแแแ แแแ NUMA แแแแแซแแแแ.
N%L โ VM แแแฎแกแแแ แแแแก แแ แแชแแแขแ แแแแแแแแ แแ NUMA แแแแแซแแ (แแฃ 80%-แแ แแแแแแแแ, แจแแแซแแแแ แฌแแ แแแแจแแแก แแฃแจแแแแแก แแ แแแแแแแแ).
แแแฎแกแแแ แแแ แฐแแแแ แแแแแ แแ
แแฃ แฐแแแแ แแแแแ แแก CPU แแ แแชแฎแแแแแแ, แ แแแแ แช แฌแแกแ, แแ แแ แแก แแแแกแแแฃแแ แแแฃแแ แแแขแแ แแกแ, แแแจแแ แแแฎแกแแแ แแแแก แจแแแแฎแแแแแจแ แกแแขแฃแแชแแ แกแแแแ แแกแแแ แแ. แแแฎแกแแแ แแแแก แแแฆแแแ แแแแแงแแแแแ VM-แแ แงแแแแแแแแก แแ แแแฃแแแแแแก แแฃแจแแแแแก แแ แแแแแแแแ, แแแแ แแ แแแฎแกแแแ แแแแก แแแฆแแแ แแแแแงแแแแแ แฐแแแแ แแแแแ แแ แแฌแแแแก แแแฎแกแแแ แแแแก แแแ แแแแก แขแแฅแแแแแก แแ แแฌแแแแก VM-แแก แแฃแจแแแแแกแแแ แแแแแแจแแ แแแฃแ แแ แแแแแแแแก. แแฅแแแ แฃแแแ แแแแแขแ แแแแ แแแกแแแแซแแแ แแแฎแกแแแ แแแแก แแแแแงแแแแแแก แกแแแแแแแแแชแแ แแ แแแแแแแ แแแชแแแแ VM-แแแ Swap-แจแ แแแฎแแแแ แแกแแแ.
แแแชแแแ
แแฃ VM แแแแญแแ แแก Swap-แจแ, แแแกแ แจแแกแ แฃแแแแ แแแแจแแแแแแแแแ แจแแแชแแ แแแแ. Balloning แแ แจแแแฃแแจแแแก แแแแแ แกแฌแ แแคแแ แฅแ แแแ แแแก แจแแแแแ, แ แแช แฃแคแแกแ แแแแ แแขแแฃแแ แแแฎแกแแแ แแแ แแแแแฉแแแแแ แฐแแกแขแแ, แแแแ แแ แแแ แขแฃแแแฃแ แ แแแแฅแแแ แแ แฉแฅแแ แแแก Swap-แแแ แกแแ แแแ แแก RAM-แจแ แแแแ แฃแแแแแก.
ESXi 6.0-แแแ VM-แแก Swap-แแแ แแแแฆแแแแก แแ แแแแแ แแ แกแแแแแแ แแ แกแฌแ แแคแ แแแ แแงแ แแแแแขแแแ แแแ (แฃแคแ แ แแฃแกแขแแ, แแแแขแแแแแ แแก แแแแแ แแแ/แฉแแ แแแ). ESXi 6.0-แแแ แแแฌแงแแแฃแแ, แแฃแแชแ แแ แ แแแแแ แแคแแชแแแแฃแ แ, แแแแแฉแแแ VM-แแก Swap-แแแ แแแแฆแแแแก แกแแแฃแจแแ แแ แกแแแแแแ แแแ. แแ แ-แแ แ แแแแคแแ แแแชแแแแ แแ แจแแแซแแแ แกแแฃแแแ แ VMware-แแก แแ แ-แแ แ แแแแแแแ แแแ, แ แแแแแแช แแแกแฃแฎแแกแแแแแแแแ CPU Scheduler-แแ. แแแ แแแแแแกแขแฃแ แ, แ แแ แแแแแแ แกแแแแแแ แแคแแฅแขแฃแ แ แแ แฃแกแแคแ แแฎแแ. แฉแแแแ แแแแแชแแแแแแแ, แแ แช แแแกแจแ แแงแ แแ แแแแแแแแ.
แ แแแแฃแ แ แแ แซแแแแแแแ VM-แแก Swap-แแแ แแแแฆแแแแกแแแแก
แ แฉแแแแแ ESXi-แแ RAM-แแก แแแ แแแแกแแแแก
แแแแแแแก, แแฅ แแ แแก แ แแแแแแแแ แ แฉแแแ, แ แแแแแแช แแแแแฎแแแ แแแแ แแแแแแแ แแแชแแแแ แแ แแแแแแแแ VM-แแก แแฃแจแแแแแกแแแ แแแแแแจแแ แแแแ RAM-แแก แแแแ:
- แแแแ แแแแ RAM-แแก แแแแแแข แแแแแฌแแ แแก แแ แแแฃแฅแขแแฃแ แแแแกแขแแ แแแจแ. แแแแแแจแแฌแแแแแแ แงแแแแแแแแก แแฅแแแแแ แแแแกแขแแ แจแ แแแแแกแฃแคแแแ แแแฎแกแแแ แแแแก ~20-30%, แ แแแ DRS-แก (แแ แแแแแแแกแขแ แแขแแ แก) แฐแฅแแแแแก แแแแแแ แแ แแแแก แแแแแแ แแ VM-แแแ แแ แแแแแแแแแแ Swap-แแ แแแแ แแชแแแก แแ แแก. แแกแแแ, แแ แแแแแแฌแงแแ แฎแแ แแแแแแแก แขแแแแ แแแขแแแแก แแฆแแแ แ. แแ แแกแแกแแแแแแแแ, แ แแแแกแแช, แ แแแแกแแช แแ แแ แกแแ แแแ แ แแจแแแแ แแ VM แแแแแแขแแแ แแแแ HA-แก แแแแแงแแแแแแ, แแแแแแ แแ แแแแฅแแแ แแกแแแ แแแแแก Swap-แแ.
- แฃแแฆแ แแกแแ แแแแกแแแแแแ แแแฃแ แแแคแ แแกแขแ แฃแฅแขแฃแ แแแจแ, แแชแแแแ, แแ แจแแฅแแแแ VM-แแแ, แ แแแแแแ แแแฎแกแแแ แแแแก แแแฎแแแแ แแ แแแขแ แแแกแแแแซแแแ แแแฎแกแแแ แแแแ. แแก แแแแแ แแแแฎแแแ แแแ DRS-แก, แฃแแ แแแแแแแ แแแแแแฌแแแแก แแแ แขแฃแแแฃแ แ แแแแฅแแแแแ แแแแกแขแแ แฃแ แกแแ แแแ แแแแ. แแก แฌแแกแ, แ แ แแฅแแ แฃแแแ, แแ แแ แแก แฃแแแแแ แกแแแฃแ แ :).
- แแแฃแคแ แแฎแแแแแ แแแกแแแแซแแแก แแแฎแกแแแ แแแแก แแแแแงแแแแแแก แกแแแแแแแแแชแแแก.
- แแ แแแแแแแฌแงแแแ VMware Tools-แแก แแแงแแแแแ VM-แแ แแ แแ แแแแแ แแแ Balooning.
- แแแแแแฎแแแแ Inter-VM TPS-แแก แฉแแ แแแ แแ แแแแ แแแแ แแแแแก แแแแแ แแแ VDI-แกแ แแ แกแแขแแกแขแ แแแ แแแแจแ.
- แแฃ VM-แก แแฅแแก แแฃแจแแแแแก แแ แแแแแแแแ, แจแแแแแฌแแแ แแงแแแแแก แแฃ แแ แ แแก แแแฎแกแแแ แแแแก แแแกแขแแแชแแฃแ แ NUMA แแแแแซแแแแ.
- แ แแช แจแแแซแแแแ แกแฌแ แแคแแ แแแแแฆแแ VM-แแแ Swap-แแแ! แกแฎแแ แกแแแแแฎแแแแแ แแ แแแ, แแฃ VM แแ แแก Swap-แจแ, แจแแแแฎแแแก แกแแกแขแแแ แแแ แแแแแแ แแจแแแ แ แแแแแแแแแก แแแแ.
แแก แงแแแแแคแแ แแ แฉแแแแแแก แ แแช แจแแแฎแแแ RAM-แก. แฅแแแแแ แแแชแแแฃแแแ แแแแแแจแแ แแแฃแแ แกแขแแขแแแแ แแแแแแแก, แแแกแแช แกแฃแ แก แฃแคแ แ แฆแ แแแ แฉแแกแแแ. แจแแแแแแ แกแขแแขแแ แแแแแแแแ storaj-แก.
แกแแกแแ แแแแแ แแแฃแแแแ
แฌแงแแ แ: www.habr.com