Guestfs-performance - ക്ലൗഡിൽ ഓൺലൈനിൽ

പട്ടിക:

NAME

guestfs-performance - ഏറ്റവും മികച്ച പ്രകടനത്തിനുള്ള എഞ്ചിനീയറിംഗ് libguestfs

വിവരണം

libguestfs-ൽ നിന്ന് ഏറ്റവും മികച്ച പ്രകടനം എങ്ങനെ നേടാമെന്ന് ഈ പേജ് രേഖപ്പെടുത്തുന്നു, പ്രത്യേകിച്ചും എപ്പോൾ
ആയിരക്കണക്കിന് വെർച്വൽ മെഷീനുകൾ അല്ലെങ്കിൽ ഡിസ്ക് ഇമേജുകൾ കൈകാര്യം ചെയ്യാൻ libguestfs ഉപയോഗിക്കുമെന്ന് നിങ്ങൾ പ്രതീക്ഷിക്കുന്നു.

മൂന്ന് പ്രധാന മേഖലകൾ ഉൾക്കൊള്ളുന്നു. Libguestfs ഒരു ഉപകരണം പ്രവർത്തിപ്പിക്കുന്നു (ഒരു ചെറിയ ലിനക്സ് വിതരണം)
qemu/KVM ഉള്ളിൽ. ആദ്യത്തെ രണ്ട് മേഖലകൾ ഇവയാണ്: ഇത് ആരംഭിക്കാൻ എടുക്കുന്ന സമയം കുറയ്ക്കുക
അപ്ലയൻസ്, അപ്ലയൻസ് എത്ര തവണ തുടങ്ങണം. മൂന്നാമത്തെ മേഖലയാണ്
VM-കളുടെ പരിശോധനയ്ക്കായി എടുക്കുന്ന സമയം കുറയ്ക്കുന്നു.

അടിസ്ഥാനരേഖ അളവുകൾ

നിങ്ങൾ libguestfs ഉപയോഗിക്കുന്ന വിധത്തിൽ മാറ്റങ്ങൾ വരുത്തുന്നതിന് മുമ്പ്, അടിസ്ഥാന അളവുകൾ എടുക്കുക.

അടിസ്ഥാനരേഖ: തുടങ്ങുന്ന The ഉപകരണം
ഒരു അൺലോഡ് ചെയ്ത മെഷീനിൽ, ഉപകരണം ആരംഭിക്കാൻ എത്ര സമയമെടുക്കും:

സമയം ഗസ്റ്റ്ഫിഷ് -a /dev/null run

ഈ കമാൻഡ് തുടർച്ചയായി നിരവധി തവണ പ്രവർത്തിപ്പിക്കുക, ആദ്യത്തെ കുറച്ച് റണ്ണുകൾ ഉപേക്ഷിക്കുക, അങ്ങനെ നിങ്ങൾ ആകും
ഒരു സാധാരണ "ഹോട്ട് കാഷെ" കേസ് അളക്കുന്നു.

വിശദീകരണം

ഈ കമാൻഡ് ഒരു നൾ ഡിസ്കിൽ libguestfs അപ്ലയൻസ് ആരംഭിക്കുന്നു, തുടർന്ന് ഉടൻ തന്നെ ഷട്ട് ചെയ്യുന്നു
അത് താഴേക്ക്. നിങ്ങൾ ആദ്യമായി കമാൻഡ് പ്രവർത്തിപ്പിക്കുമ്പോൾ, അത് ഒരു ഉപകരണം സൃഷ്ടിച്ച് അത് കാഷെ ചെയ്യും
(സാധാരണയായി താഴെ /var/tmp/.guestfs-*). തുടർന്നുള്ള റണ്ണുകൾ കാഷെ ചെയ്‌ത ഉപകരണം വീണ്ടും ഉപയോഗിക്കണം.

പ്രതീക്ഷിച്ചത് ഫലം

6 സെക്കൻഡിൽ താഴെ സമയം ലഭിക്കുമെന്ന് നിങ്ങൾ പ്രതീക്ഷിക്കണം. നിങ്ങൾ ഒരു ന് കാണുന്ന തവണ എങ്കിൽ
അൺലോഡഡ് മെഷീൻ ഇതിന് മുകളിലാണ്, തുടർന്ന് "ട്രബിൾഷൂട്ടിംഗ് മോശം പ്രകടനം" എന്ന വിഭാഗം കാണുക
താഴെ.

അടിസ്ഥാനരേഖ: പ്രകടനം പരിശോധന of a അതിഥി
ഈ പരിശോധനയ്ക്കായി നിങ്ങൾക്ക് ഒരു അൺലോഡ് ചെയ്ത മെഷീനും കുറഞ്ഞത് ഒരു യഥാർത്ഥ അതിഥി അല്ലെങ്കിൽ ഡിസ്ക് ഇമേജും ആവശ്യമാണ്.
നിങ്ങൾ X അതിഥികൾക്കെതിരെ മാത്രം libguestfs ഉപയോഗിക്കാൻ പദ്ധതിയിടുകയാണെങ്കിൽ (ഉദാ. X = Windows), തുടർന്ന് ഉപയോഗിക്കുക
ഇവിടെ ഒരു X അതിഥിയാണ് ഏറ്റവും അനുയോജ്യം. നിങ്ങൾ ഇതിനെതിരെ libguestfs പ്രവർത്തിപ്പിക്കാൻ പദ്ധതിയിടുകയാണെങ്കിൽ
അതിഥികളുടെ ഒരു മിശ്രിതം, തുടർന്ന് ഇവിടെ പരിശോധനയ്ക്കായി അതിഥികളുടെ ഒരു മിശ്രിതം ഉപയോഗിക്കുക.

പരിശോധന നടത്താനും അതിഥിയുടെ ഡിസ്കുകൾ മൌണ്ട് ചെയ്യാനും എത്ര സമയമെടുക്കും. ഉപയോഗിക്കുക
നിങ്ങൾ ഡിസ്ക് ഇമേജുകൾ ഉപയോഗിക്കുകയാണെങ്കിൽ ആദ്യ കമാൻഡ്, നിങ്ങളാണെങ്കിൽ രണ്ടാമത്തെ കമാൻഡ്
libvirt ഉപയോഗിക്കുന്നു.

ടൈം ഗസ്റ്റ്ഫിഷ് --റോ -എ disk.img -i എക്സിറ്റ്

സമയം അതിഥി മത്സ്യം --ro -d GuestName -i എക്സിറ്റ്

കമാൻഡ് തുടർച്ചയായി നിരവധി തവണ പ്രവർത്തിപ്പിക്കുക, ആദ്യത്തെ കുറച്ച് റണ്ണുകൾ നിരസിക്കുക, അങ്ങനെ നിങ്ങൾ ആകും
ഒരു സാധാരണ "ഹോട്ട് കാഷെ" കേസ് അളക്കുന്നു.

വിശദീകരണം

ഈ കമാൻഡ് ഡിസ്ക് ഇമേജിലോ libvirt ഗസ്റ്റിലോ libguestfs അപ്ലയൻസ് ആരംഭിക്കുന്നു,
അതിൽ libguestfs പരിശോധന നടത്തുന്നു ("ഇൻസ്പെക്ഷൻ" കാണുക അതിഥികൾ(3)), അതിഥിയുടെ മൌണ്ട് ചെയ്യുന്നു
ഡിസ്കുകൾ, തുടർന്ന് ഈ ഫലങ്ങളെല്ലാം നിരസിക്കുകയും ഷട്ട്ഡൗൺ ചെയ്യുകയും ചെയ്യുന്നു.

നിങ്ങൾ ആദ്യമായി കമാൻഡ് പ്രവർത്തിപ്പിക്കുമ്പോൾ, അത് ഒരു ഉപകരണം സൃഷ്ടിച്ച് അത് കാഷെ ചെയ്യും (സാധാരണയായി
കീഴെ /var/tmp/.guestfs-*). തുടർന്നുള്ള റണ്ണുകൾ കാഷെ ചെയ്‌ത ഉപകരണം വീണ്ടും ഉപയോഗിക്കണം.

പ്രതീക്ഷിച്ചത് ഫലം

ആദ്യ ബേസ്‌ലൈനിൽ കണക്കാക്കിയതിനേക്കാൾ ≤ 5 സെക്കൻഡ് കൂടുതലുള്ള സമയങ്ങൾ നിങ്ങൾ പ്രതീക്ഷിക്കണം
മുകളിൽ ടെസ്റ്റ്. (ഉദാഹരണത്തിന്, ആദ്യത്തെ അടിസ്ഥാന പരിശോധന 5 സെക്കൻഡിനുള്ളിൽ ഓടിയെങ്കിൽ, ഈ ടെസ്റ്റ്
≤ 10 സെക്കൻഡിനുള്ളിൽ പ്രവർത്തിക്കണം).

മനസ്സിലാക്കൽ ദി പ്രയോഗം ഒപ്പം എപ്പോൾ IT IS ബിൽറ്റ്/കാഷെഡ്

നിങ്ങൾ ആദ്യമായി libguestfs ഉപയോഗിക്കുമ്പോൾ, അത് ഒരു ഉപകരണം നിർമ്മിക്കുകയും കാഷെ ചെയ്യുകയും ചെയ്യും. ഇത് സാധാരണയാണ്
in /var/tmp/.guestfs-*, നിങ്ങൾ $TMPDIR അല്ലെങ്കിൽ $LIBGUESTFS_CACHEDIR സജ്ജീകരിച്ചിട്ടില്ലെങ്കിൽ
അത് ആ താൽക്കാലിക ഡയറക്‌ടറിക്ക് കീഴിലായിരിക്കും.

അപ്ലയൻസ് എങ്ങനെ നിർമ്മിക്കപ്പെടുന്നു എന്നതിനെക്കുറിച്ചുള്ള കൂടുതൽ വിവരങ്ങൾക്ക്, "സൂപ്പർമിൻ അപ്ലയൻസ്" കാണുക
സൂപ്പർമിൻ(1).

ഓരോ തവണയും libguestfs പ്രവർത്തിപ്പിക്കുമ്പോൾ അത് അപ്ലയൻസ് ഉപയോഗിക്കുന്ന ഹോസ്റ്റ് ഫയലുകൾ ഇല്ലെന്ന് പരിശോധിക്കും
മാറി. എന്തെങ്കിലും ഉണ്ടെങ്കിൽ, ഉപകരണം പുനർനിർമ്മിച്ചു. ഒരു പാക്കേജ് ചെയ്യുമ്പോൾ ഇത് സാധാരണയായി സംഭവിക്കുന്നു
ഹോസ്റ്റിൽ ഇൻസ്റ്റാൾ ചെയ്യുകയോ അപ്ഡേറ്റ് ചെയ്യുകയോ ചെയ്തു (ഉദാ. "yum" അല്ലെങ്കിൽ "apt-get" പോലുള്ള പ്രോഗ്രാമുകൾ ഉപയോഗിക്കുന്നത്). ദി
അപ്ലയൻസ് പുനർനിർമ്മിക്കുന്നതിനുള്ള കാരണം സുരക്ഷയാണ്: പുതിയ പ്രോഗ്രാം
ഇൻസ്റ്റാൾ ചെയ്തതിൽ ഒരു സുരക്ഷാ പരിഹാരം അടങ്ങിയിരിക്കാം, അതിനാൽ ഫിക്സഡ് പ്രോഗ്രാം ഉൾപ്പെടുത്താൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്നു
ഉപകരണം സ്വയമേവ.

പ്രകടനത്തിന്റെ സൂചനകൾ ഇവയാണ്:

· കാഷെ ചെയ്‌ത ഉപകരണം നിർമ്മിക്കുന്ന (അല്ലെങ്കിൽ പുനർനിർമ്മിക്കുന്ന) പ്രക്രിയ മന്ദഗതിയിലാണ്, നിങ്ങൾക്ക് കഴിയും
ഒരു നിശ്ചിത ഉപകരണം ഉപയോഗിച്ച് ഇത് സംഭവിക്കുന്നത് ഒഴിവാക്കുക (ചുവടെ കാണുക).

· ഒരു നിശ്ചിത ഉപകരണം ഉപയോഗിക്കുന്നില്ലെങ്കിൽ, ഹോസ്റ്റിൽ സോഫ്‌റ്റ്‌വെയർ അപ്‌ഡേറ്റ് ചെയ്യുന്നത് കാരണമാകുമെന്ന് അറിഞ്ഞിരിക്കുക
ഉപകരണത്തിന്റെ ഒറ്റത്തവണ പുനർനിർമ്മാണം.

· / var / tmp (അല്ലെങ്കിൽ $TMPDIR, $LIBGUESTFS_CACHEDIR) ഒരു ഫാസ്റ്റ് ഡിസ്കിലായിരിക്കണം, കൂടാതെ ധാരാളം ഉണ്ടായിരിക്കണം.
ഉപകരണത്തിനുള്ള സ്ഥലം.

ഉപയോഗിക്കുന്നു A നിശ്ചിത പ്രയോഗം

ഉപകരണം നിർമ്മിക്കുമ്പോൾ പൂർണ്ണമായി നിയന്ത്രിക്കുന്നതിന്, നിങ്ങൾക്ക് ഒരു നിശ്ചിത ഉപകരണം നിർമ്മിക്കാൻ കഴിയും. ഈ
ഉപകരണം ഒരു ഫാസ്റ്റ് ലോക്കൽ ഡിസ്കിൽ സൂക്ഷിക്കണം.

ഉപകരണം നിർമ്മിക്കുന്നതിന്, കമാൻഡ് പ്രവർത്തിപ്പിക്കുക:

libguestfs-make-fixed-appliance

മാറ്റിസ്ഥാപിക്കുന്നു" "അപ്ലയൻസ് സൂക്ഷിച്ചിരിക്കുന്ന ഒരു ഡയറക്ടറിയുടെ പേരിനൊപ്പം
(സാധാരണയായി നിങ്ങൾ ഒരു ഉപഡയറക്‌ടറിക്ക് പേരിടും, ഉദാഹരണത്തിന്: /usr/local/lib/guestfs/appliance or
/dev/shm/appliance).

തുടർന്ന് $LIBGUESTFS_PATH സജ്ജീകരിക്കുക (ഈ എൻവയോൺമെന്റ് വേരിയബിൾ നിങ്ങളുടെ libguestfs-ൽ സജ്ജീകരിച്ചിട്ടുണ്ടെന്ന് ഉറപ്പാക്കുക
പ്രോഗ്രാം), അല്ലെങ്കിൽ നിങ്ങളുടെ പ്രോഗ്രാം പരിഷ്ക്കരിക്കുക, അങ്ങനെ അത് "guestfs_set_path" എന്ന് വിളിക്കുന്നു. ഉദാഹരണത്തിന്:

LIBGUESTFS_PATH=/usr/local/lib/guestfs/appliance കയറ്റുമതി ചെയ്യുക

ഇപ്പോൾ നിങ്ങൾക്ക് libguestfs പ്രോഗ്രാമുകൾ, virt ടൂളുകൾ, ഗസ്റ്റ്ഫിഷ് മുതലായവ സാധാരണ പോലെ പ്രവർത്തിപ്പിക്കാം. പരിപാടികൾ
നിങ്ങളുടെ സ്ഥിരമായ ഉപകരണം ഉപയോഗിക്കും, ഒരിക്കലും സ്വന്തമായി നിർമ്മിക്കുകയോ പുനർനിർമ്മിക്കുകയോ കാഷെ ചെയ്യുകയോ ചെയ്യില്ല
ഉപകരണം.

(ഈ വിഷയത്തെക്കുറിച്ചുള്ള വിശദമായ വിവരങ്ങൾക്ക്, കാണുക: libguestfs-make-fixed-appliance(1)).

പ്രകടനം of The നിശ്ചിത ഉപകരണം
ഞങ്ങളുടെ പരിശോധനയിൽ ഒരു നിശ്ചിത ഉപകരണത്തിന്റെ ഉപയോഗം അളക്കാൻ കഴിയുന്ന എന്തെങ്കിലും നൽകുന്നതായി ഞങ്ങൾ കണ്ടെത്തിയില്ല
അപ്ലയൻസ് മെമ്മറിയിൽ സ്ഥിതി ചെയ്‌തിരിക്കുമ്പോൾ പോലും പ്രകടന നേട്ടം (അതായത് /dev/shm).
എന്നിരുന്നാലും പരിഗണിക്കേണ്ട രണ്ട് പോയിന്റുകൾ ഉണ്ട്:

1. ഒരു നിശ്ചിത ഉപകരണത്തിന്റെ ഉപയോഗം, ഉപകരണം പുനർനിർമ്മിക്കുന്നതിൽ നിന്ന് libguestfs നിർത്തുന്നു, അർത്ഥം
libguestfs-ന് കൂടുതൽ പ്രവചിക്കാവുന്ന ആരംഭ സമയമുണ്ടാകും.

2. അപ്ലയൻസ് ആവശ്യാനുസരണം ലോഡ് ചെയ്യുന്നു. ഇതുപോലുള്ള ഒരു ലളിതമായ പരിശോധന:

സമയം ഗസ്റ്റ്ഫിഷ് -a /dev/null run

ഉപകരണം വളരെയധികം ലോഡ് ചെയ്യുന്നില്ല. സങ്കീർണ്ണമായ ഒരു യഥാർത്ഥ libguestfs പ്രോഗ്രാം
API കോളുകൾ അപ്ലയൻസിൻറെ കൂടുതൽ ലോഡുകളെ ആവശ്യപ്പെടും. സംഭരിക്കാൻ കഴിയുന്നത്
ഒരു നിർദ്ദിഷ്‌ട ലൊക്കേഷനിലെ ഉപകരണം പ്രകടനത്തെ കൂടുതൽ പ്രവചിക്കാവുന്നതാക്കുന്നു.

കുറയ്ക്കുന്നു ദി NUMBER OF TIMES ദി പ്രയോഗം IS വിക്ഷേപിച്ചു

മികച്ച പ്രകടനം നേടുന്നതിനുള്ള ഏറ്റവും ലളിതമായ മാർഗ്ഗം അല്ലെങ്കിലും ഏറ്റവും ഫലപ്രദമാണ്
ഉപകരണം ഏറ്റവും കുറഞ്ഞ തവണ ലോഞ്ച് ചെയ്തിട്ടുണ്ടെന്ന് ഉറപ്പാക്കാൻ. ഇത് ഒരുപക്ഷേ ചെയ്യും
നിങ്ങളുടെ libguestfs ആപ്ലിക്കേഷൻ മാറ്റുന്നതിൽ ഉൾപ്പെടുന്നു.

ഒരു ടാർഗെറ്റ് വെർച്വൽ മെഷീനിലോ ഡിസ്ക് ഇമേജിലോ ഒരു തവണയെങ്കിലും "guestfs_launch" എന്ന് വിളിക്കാൻ ശ്രമിക്കുക.

ഒരു പ്രത്യേക ഉദാഹരണം ഉപയോഗിക്കുന്നതിന് പകരം അതിഥി മത്സ്യം(1) എന്നതിലേക്ക് മാറ്റങ്ങളുടെ ഒരു പരമ്പര വരുത്തുക
ഒരേ അതിഥി, ഗസ്റ്റ് ഫിഷിന്റെ ഒരൊറ്റ ഉദാഹരണം ഉപയോഗിക്കുക കൂടാതെ/അല്ലെങ്കിൽ ഗസ്റ്റ് ഫിഷ് ഉപയോഗിക്കുക --കേൾക്കുക ഓപ്ഷൻ.

ഒരു സീരീസ് നിർമ്മിക്കുമ്പോൾ അതിഥിയെ തുറന്ന് നിർത്തുന്ന ഡെമൺ ആയി നിങ്ങളുടെ പ്രോഗ്രാം എഴുതുന്നത് പരിഗണിക്കുക
മാറ്റങ്ങളുടെ. അല്ലെങ്കിൽ അതിഥിയെ തുറക്കുന്നതിന് മുമ്പ് നിങ്ങൾ ചെയ്യാൻ ആഗ്രഹിക്കുന്ന എല്ലാ പ്രവർത്തനങ്ങളും മാർഷൽ ചെയ്യുക.

നിങ്ങൾക്ക് ഒരു ഉപകരണത്തിലേക്ക് ഒന്നിലധികം അതിഥികളിൽ നിന്ന് ഡിസ്കുകൾ ചേർക്കാനും ശ്രമിക്കാവുന്നതാണ്. ശ്രമിക്കുന്നതിന് മുമ്പ്
ഇത്, ഇനിപ്പറയുന്ന പോയിന്റുകൾ ശ്രദ്ധിക്കുക:

1. ഒരു ഉപകരണത്തിലേക്ക് ഒന്നിലധികം അതിഥികളെ ചേർക്കുന്നത് ഒരു സുരക്ഷാ പ്രശ്നമാണ്, കാരണം അത് ഒരെണ്ണം അനുവദിച്ചേക്കാം
മറ്റൊരു അതിഥിയുടെ ഡിസ്കുകളിൽ ഇടപെടാൻ അതിഥി. എല്ലാത്തിലും വിശ്വാസമുണ്ടെങ്കിൽ മാത്രം ചെയ്യുക
അതിഥികൾ, അല്ലെങ്കിൽ നിങ്ങൾക്ക് വിശ്വാസപ്രകാരം അതിഥികളെ ഗ്രൂപ്പുചെയ്യാൻ കഴിയുമെങ്കിൽ.

2. ഒരൊറ്റ അപ്ലയൻസിലേക്ക് ചേർക്കാൻ കഴിയുന്ന ഡിസ്കുകളുടെ എണ്ണത്തിന് ഹാർഡ് ലിമിറ്റ് ഉണ്ട്. വിളി
"guestfs_max_disks" ൽ അതിഥികൾ(3) ഈ പരിധി ലഭിക്കാൻ. കൂടുതൽ വിവരങ്ങൾക്ക് കാണുക
"പരിമിതികൾ" അതിഥികൾ(3).

3. ഈ രീതിയിൽ libguestfs ഉപയോഗിക്കുന്നത് സങ്കീർണ്ണമാണ്. ഡിസ്കുകൾക്ക് അപ്രതീക്ഷിത ഇടപെടലുകൾ ഉണ്ടാകാം: വേണ്ടി
ഉദാഹരണത്തിന്, രണ്ട് അതിഥികൾ ഒരു ഫയൽസിസ്റ്റത്തിന് ഒരേ UUID ഉപയോഗിക്കുന്നുവെങ്കിൽ (അവർ ക്ലോൺ ചെയ്തതിനാൽ)
അല്ലെങ്കിൽ അതേ പേരിൽ വോളിയം ഗ്രൂപ്പുകൾ ഉണ്ടായിരിക്കണം (എന്നാൽ "guestfs_lvm_set_filter" കാണുക).

virt-df(1) സ്ഥിരസ്ഥിതിയായി ഒന്നിലധികം ഡിസ്കുകൾ ചേർക്കുന്നു, അതിനാൽ ഈ പ്രോഗ്രാമിന്റെ സോഴ്സ് കോഡ് a ആയിരിക്കും
ആരംഭിക്കാൻ നല്ല സ്ഥലം.

ചുരുക്കുന്നു ദി TIME, എടുത്തു വേണ്ടി ഇൻസ്പെക്ഷൻ OF വി.എം.

പ്രധാന ഉപദേശം വ്യക്തമാണ്: നിങ്ങൾക്ക് ആവശ്യമില്ലെങ്കിൽ പരിശോധന നടത്തരുത് (ഇത് ചെലവേറിയതാണ്).
ഫലങ്ങൾ.

നിങ്ങൾ മുമ്പ് അതിഥിയിൽ പരിശോധന നടത്തിയിരുന്നെങ്കിൽ, അത് കാഷെ ചെയ്യാൻ സുരക്ഷിതമായിരിക്കും
കഴിഞ്ഞ തവണത്തെ ഫലങ്ങൾ വീണ്ടും ഉപയോഗിക്കുക.

ചില ഡിസ്കുകൾ പരിശോധിക്കേണ്ടതില്ല: ഉദാഹരണത്തിന്, നിങ്ങൾ ഒരു ഡിസ്ക് സൃഷ്ടിക്കുകയാണെങ്കിൽ
ഇമേജ്, അല്ലെങ്കിൽ ഡിസ്ക് ഇമേജ് ഒരു വിഎം അല്ലെങ്കിലോ അല്ലെങ്കിൽ ഡിസ്ക് ഇമേജിന് അറിയപ്പെടുന്ന ലേഔട്ട് ഉണ്ടെങ്കിലോ.

അടിസ്ഥാന പരിശോധന ("guestfs_inspect_os") ആവശ്യമുള്ളപ്പോൾ പോലും, സഹായ പരിശോധന
പ്രവർത്തനങ്ങൾ ഒഴിവാക്കാം:

· കൂടുതൽ ഫയൽസിസ്റ്റം വിവരങ്ങൾ ലഭിക്കുന്നതിന് ഡിസ്കുകൾ മൗണ്ടുചെയ്യുന്നത് ആവശ്യമാണ്.

ലിസ്റ്റിംഗ് ആപ്ലിക്കേഷനുകൾ ("guestfs_inspect_list_applications") ഒരു ചെലവേറിയ പ്രവർത്തനമാണ്
ലിനക്സിൽ, എന്നാൽ വിൻഡോസിൽ ഏറെക്കുറെ സൗജന്യമാണ്.

· ഒരു അതിഥി ഐക്കൺ സൃഷ്ടിക്കുന്നത് ("guestfs_inspect_get_icon") Linux-ൽ വിലകുറഞ്ഞതും എന്നാൽ ചെലവേറിയതുമാണ്
വിൻഡോസിൽ.

പാരലൽ വീട്ടുപകരണങ്ങൾ

Libguestfs വീട്ടുപകരണങ്ങൾ കൂടുതലും I/O ബന്ധിതമാണ്, നിങ്ങൾക്ക് ഒന്നിലധികം വീട്ടുപകരണങ്ങൾ ലോഞ്ച് ചെയ്യാം
സമാന്തരമായി. ആവശ്യത്തിന് സൗജന്യ മെമ്മറി ഉണ്ടെങ്കിൽ, അതിൽ ചെറിയ വ്യത്യാസം ഉണ്ടായിരിക്കണം
സമാന്തരമായി 1 അപ്ലയൻസ് vs N വീട്ടുപകരണങ്ങൾ സമാരംഭിക്കുന്നു.

(പ്രത്യേകിച്ച് റിയലിസ്റ്റിക് അല്ല) ടെസ്റ്റ് ഉപയോഗിച്ച്, 2 GB റാമുള്ള 4-കോർ (16-ത്രെഡ്) ലാപ്‌ടോപ്പിൽ
താഴെയുള്ള പേൾ സ്‌ക്രിപ്റ്റ്, 1-ന് ഇടയിൽ പ്രവർത്തിക്കുമ്പോൾ ഇനിപ്പറയുന്ന പ്ലോട്ട് മികച്ച സ്കേലബിളിറ്റി കാണിക്കുന്നു
കൂടാതെ 20 വീട്ടുപകരണങ്ങൾ സമാന്തരമായി:

12 - -++
+ + + + + + + + + + + * *
| |
| * |
11 ++ ++
| |
| |
| * * |
10 ++ ++
| * |
| |
s | |
9 ++ ++
ഇ | |
| * |
സി | |
8 ++ * ++
ഒ | * |
| |
n 7 ++ ++
| * |
d | * |
| |
s 6 ++ ++
| * * |
| * |
| |
5 ++ ++
| |
| * |
| * * |
4 ++ ++
| |
| |
+ * * * + + + + + + + + +
3 -++
0 2 4 6 8 10 12 14 16 18
സമാന്തര ഉപകരണങ്ങളുടെ എണ്ണം

സമാന്തരമായി 20-ലധികം വീട്ടുപകരണങ്ങൾ പ്രവർത്തിപ്പിക്കാൻ കഴിയും, എന്നാൽ നിങ്ങൾ ഉപയോഗിക്കുകയാണെങ്കിൽ
libvirt ബാക്കെൻഡ് അപ്പോൾ നിങ്ങൾ അറിഞ്ഞിരിക്കണം, libvirt ബോക്‌സിന് പുറത്ത് ഇവയുടെ എണ്ണം പരിമിതപ്പെടുത്തുന്നു
20 ലേക്കുള്ള ക്ലയന്റ് കണക്ഷനുകൾ.

മുകളിലുള്ള പ്ലോട്ടിന്റെ ഡാറ്റ ശേഖരിക്കാൻ ചുവടെയുള്ള ലളിതമായ പേൾ സ്ക്രിപ്റ്റ് ഉപയോഗിച്ചു, പക്ഷേ ഉണ്ട്
കൂടുതൽ വിപുലമായ ടെസ്റ്റ് സ്ക്രിപ്റ്റുകളും ഗ്രാഫുകളും ഉൾപ്പെടെ ഈ വിഷയത്തെക്കുറിച്ചുള്ള കൂടുതൽ വിവരങ്ങൾ,
ഇനിപ്പറയുന്ന ബ്ലോഗ് പോസ്റ്റിംഗുകളിൽ ലഭ്യമാണ്:

http://rwmj.wordpress.com/2013/02/25/multiple-libguestfs-appliances-in-parallel-part-1/
http://rwmj.wordpress.com/2013/02/25/multiple-libguestfs-appliances-in-parallel-part-2/
http://rwmj.wordpress.com/2013/02/25/multiple-libguestfs-appliances-in-parallel-part-3/
http://rwmj.wordpress.com/2013/02/25/multiple-libguestfs-appliances-in-parallel-part-4/

#!/usr/bin/env മുത്ത്

കർശനമായി ഉപയോഗിക്കുക;
ത്രെഡുകൾ ഉപയോഗിക്കുക;
മുന്നറിയിപ്പുകൾ ഉപയോഗിക്കുക;
Sys ::Guestfs ഉപയോഗിക്കുക;
സമയം ഉപയോഗിക്കുക::HiRes qw(സമയം);

ഉപ പരീക്ഷ {
എന്റെ $g = Sys::Guestfs->പുതിയ;
$g->add_drive_ro ("/dev/null");
$g->ലോഞ്ച് ();

# libguestfs-നായി നിങ്ങൾക്ക് ഇവിടെ ചില ജോലികൾ ചേർക്കാവുന്നതാണ്.

$g->അടയ്ക്കുക ();
}

# എല്ലാം കാഷെയിൽ കൊണ്ടുവരിക.
ടെസ്റ്റ് (); ടെസ്റ്റ് (); ടെസ്റ്റ് ();

എന്റെ $nr_threads-ന് (1..20) {
എന്റെ $start_t = സമയം ();
എന്റെ @ത്രെഡുകൾ;
foreach (1..$nr_threads) {
പുഷ് @ത്രെഡുകൾ, ത്രെഡുകൾ->സൃഷ്ടിക്കുക (\&ടെസ്റ്റ്)
}
ഫോറെച്ച് (@ത്രെഡുകൾ) {
$_->ചേരുക ();
എങ്കിൽ (എന്റെ $err = $_->പിശക് ()) {
ഡൈ "$nr_threads ത്രെഡുകൾ ഉപയോഗിച്ച് ലോഞ്ച് പരാജയപ്പെട്ടു: $err"
}
}
എന്റെ $end_t = സമയം ();
printf ("%d %.2f\n", $nr_threads, $end_t - $start_t);
}

ഉപയോഗിക്കുന്നു ഉപയോക്താവ്-മോഡ് Linux

libguestfs 1.24 മുതൽ, ഉപയോക്തൃ-മോഡ് ലിനക്സ് (uml) ബാക്കെൻഡ് ഉപയോഗിക്കുന്നത് സാധ്യമാണ്.
KVM-ന് പകരം ("USER-MODE LINUX BACKEND" കാണുക അതിഥികൾ(3)). ഈ വിഭാഗം ചിലത് ഉണ്ടാക്കുന്നു
ഈ ബാക്കെൻഡിനെക്കുറിച്ചുള്ള പൊതുവായ അഭിപ്രായങ്ങൾ, പക്ഷേ അങ്ങനെയാണ് വളരെ ഉചിതം നിങ്ങളുടെ സ്വന്തം അളക്കാൻ
അഭിപ്രായങ്ങളെയോ അവബോധത്തെയോ വിശ്വസിക്കുന്നതിനുപകരം UML-ന് കീഴിൽ ജോലിഭാരം.

· UML സാധാരണയായി കെവിഎമ്മിനേക്കാൾ സമാനമോ ചെറുതായി സാവധാനമോ ആണ്, ബാർമെറ്റലിൽ പ്രവർത്തിക്കുന്നത്.

എന്നിരുന്നാലും, UML പലപ്പോഴും വെർച്വലൈസേഷനിൽ പ്രവർത്തിക്കുന്നത് ബാർമെറ്റലിൽ ചെയ്യുന്നതുപോലെയാണ്,
വിർച്ച്വലൈസേഷനിൽ കെവിഎമ്മിന് വളരെ സാവധാനത്തിൽ പ്രവർത്തിക്കാൻ കഴിയും (ഹാർഡ്‌വെയർ വിർട്ട് ആക്സിലറേഷൻ മുതൽ
ലഭ്യമല്ല).

· അപ്‌ലോഡും ഡൗൺലോഡും UML-ൽ KVM-നേക്കാൾ 10 മടങ്ങ് വേഗത കുറവാണ്. Libguestfs അയയ്ക്കുന്നു
യുഎംഎൽ എമുലേറ്റഡ് സീരിയൽ പോർട്ടിലൂടെയുള്ള ഈ ഡാറ്റ, കെവിഎമ്മിനേക്കാൾ കാര്യക്ഷമത കുറവാണ്
virtio-സീരിയൽ.

· UML-ന് ചില സവിശേഷതകൾ ഇല്ല (ഉദാ. qcow2 പിന്തുണ), അതിനാൽ ഇത് ബാധകമായേക്കില്ല.

ചില യഥാർത്ഥ കണക്കുകൾക്കായി, കാണുക:
http://rwmj.wordpress.com/2013/08/14/performance-of-user-mode-linux-as-a-libguestfs-backend/#ചൊംതെംത്

ട്രബിൾഷൂട്ടിംഗ് മോശം PERFORMANCE

ഉറപ്പാക്കുക ഹാർഡ്വെയർ വിർച്വലൈസേഷൻ is ലഭ്യമായ
ഉപയോഗം / proc / cpuinfo ഈ പേജും:

http://virt-tools.org/learning/check-hardware-virt/

ഹാർഡ്‌വെയർ വിർച്ച്വലൈസേഷൻ ലഭ്യമാണെന്ന് ഉറപ്പാക്കാൻ. നിങ്ങൾ ഇത് പ്രവർത്തനക്ഷമമാക്കേണ്ടതായി വരാം എന്നത് ശ്രദ്ധിക്കുക
നിങ്ങളുടെ BIOS-ൽ.

ഹാർഡ്‌വെയർ virt സാധാരണയായി VM-കൾക്കുള്ളിൽ ലഭ്യമല്ല, ഒപ്പം libguestfs ഉള്ളിൽ സാവധാനം പ്രവർത്തിക്കും
നിങ്ങൾ എന്ത് ചെയ്താലും മറ്റൊരു വെർച്വൽ മെഷീൻ. നെസ്റ്റഡ് വെർച്വലൈസേഷൻ നമ്മിൽ നന്നായി പ്രവർത്തിക്കുന്നില്ല
അനുഭവപരിചയം, തീർച്ചയായും ഇത് baremetal-ൽ libguestfs പ്രവർത്തിപ്പിക്കുന്നതിന് പകരമാവില്ല.

ഉറപ്പാക്കുക കെവിഎം is ലഭ്യമായ
കെവിഎം പ്രവർത്തനക്ഷമമാക്കിയിട്ടുണ്ടെന്നും libguestfs പ്രവർത്തിപ്പിക്കുന്ന ഉപയോക്താവിന് ലഭ്യമാണെന്നും ഉറപ്പാക്കുക. ഇത് ചെയ്തിരിക്കണം
0666 അനുമതികൾ സജ്ജമാക്കാൻ സുരക്ഷിതരായിരിക്കുക /dev/kvm ഇപ്പോൾ മിക്ക വിതരണങ്ങളും ഇത് ചെയ്യുന്നു.

സംസ്ക്കരിക്കുന്നവർ ലേക്ക് ഒഴിവാക്കുക
ഹാർഡ്‌വെയർ വിർച്ച്വലൈസേഷൻ ഇല്ലാത്ത പ്രോസസ്സറുകളും ചില പ്രോസസ്സറുകളും ഒഴിവാക്കുക
വളരെ സാവധാനം (എഎംഡി ജിയോഡ് ഒരു മികച്ച ഉദാഹരണമാണ്).

സെൻ സൂര്യൻ 0
Xen-ൽ, dom0 ഒരു വെർച്വൽ മെഷീനാണ്, അതിനാൽ ഹാർഡ്‌വെയർ വിർച്ച്വലൈസേഷൻ ലഭ്യമല്ല.

വിശദമായ സമയം ഉപയോഗിക്കുന്നു TS

ഉപയോഗിക്കുക ts(1) വിശദമായ സമയക്രമം കാണിക്കാൻ (morutils ൽ നിന്ന്) കമാൻഡ്:

$ അതിഥി മത്സ്യം -a /dev/null run -v |& ts -i '%.s'
0.000022 libguestfs: launch: program=guestfish
0.000134 libguestfs: ലോഞ്ച്: പതിപ്പ്=1.29.31fedora=23,release=2.fc23,libvirt
0.000044 libguestfs: ലോഞ്ച്: ബാക്കെൻഡ് രജിസ്റ്റർ ചെയ്തത്: unix
0.000035 libguestfs: ലോഞ്ച്: ബാക്കെൻഡ് രജിസ്റ്റർ ചെയ്തു: uml
0.000035 libguestfs: ലോഞ്ച്: ബാക്കെൻഡ് രജിസ്റ്റർ ചെയ്തു: libvirt
0.000032 libguestfs: ലോഞ്ച്: ബാക്കെൻഡ് രജിസ്റ്റർ ചെയ്തത്: ഡയറക്ട്
0.000030 libguestfs: ലോഞ്ച്: backend=libvirt
0.000031 libguestfs: ലോഞ്ച്: tmpdir=/tmp/libguestfsw18rBQ
0.000029 libguestfs: ലോഞ്ച്: umask=0002
0.000031 libguestfs: ലോഞ്ച്: euid=1000
0.000030 libguestfs: libvirt പതിപ്പ് = 1002012 (1.2.12)
[തുടങ്ങിയവ]

ടൈംസ്റ്റാമ്പുകൾ സെക്കൻഡുകളാണ് (മുമ്പത്തെ വരിയിൽ നിന്ന് വർദ്ധനയോടെ).

വിശദമായ സമയം ഉപയോഗിക്കുന്നു സിസ്റ്റംടാപ്പ്

നിങ്ങൾക്ക് SystemTap ഉപയോഗിക്കാം (സ്റ്റാപ്പ്(1)) libguestfs പ്രോഗ്രാമുകളിൽ നിന്ന് വിശദമായ സമയങ്ങൾ ലഭിക്കുന്നതിന്.

ഇനിപ്പറയുന്ന സ്ക്രിപ്റ്റ് ഇതായി സംരക്ഷിക്കുക time.stap:

ആഗോള അവസാനം;

ഫംഗ്‌ഷൻ ഡിസ്പ്ലേ_ടൈം () {
ഇപ്പോൾ = gettimeofday_us ();
ഡെൽറ്റ = 0;
എങ്കിൽ (അവസാനം > 0)
ഡെൽറ്റ = ഇപ്പോൾ - അവസാനത്തേത്;
അവസാന = ഇപ്പോൾ;

printf ("%d (+%d):", ഇപ്പോൾ, ഡെൽറ്റ);
}

അന്വേഷണം ആരംഭിക്കുക {
അവസാന = 0;
printf ("തയ്യാറാണ്\n");
}

/* സ്റ്റാറ്റിക് മാർക്കറുകളിലേക്ക് എല്ലാ കോളുകളും പ്രദർശിപ്പിക്കുക. */
അന്വേഷണ പ്രക്രിയ ("/ Usr / lib*/libguestfs.so.0")
.provider("guestfs").mark("*") ? {
display_time();
printf ("\t%s %s\n", $$name, $$parms);
}

/*gestfs_* ഫംഗ്‌ഷനുകളിലേക്കുള്ള എല്ലാ കോളുകളും പ്രദർശിപ്പിക്കുക. */
അന്വേഷണ പ്രക്രിയ ("/ Usr / lib*/libguestfs.so.0")
.ഫംഗ്ഷൻ("guestfs_[az]*") ? {
display_time();
printf ("\t%s %s\n", probefunc(), $$parms);
}

ഒരു വിൻഡോയിൽ റൂട്ട് ആയി പ്രവർത്തിപ്പിക്കുക:

# സ്റ്റാപ്പ് സമയം.സ്റ്റാപ്പ്
തയ്യാറാണ്

SystemTap പ്രോഗ്രാം ലോഡ് ചെയ്യുമ്പോൾ അത് "റെഡി" എന്ന് പ്രിന്റ് ചെയ്യുന്നു. നിങ്ങളുടെ libguestfs പ്രോഗ്രാം പ്രവർത്തിപ്പിക്കുക,
അതിഥി മത്സ്യം അല്ലെങ്കിൽ മറ്റൊരു വിൻഡോയിൽ ഒരു virt ടൂൾ. ഉദാഹരണത്തിന്:

$ അതിഥി മത്സ്യം -a /dev/null run

സ്റ്റാപ്പ് വിൻഡോയിൽ, ഓരോന്നിനും എടുക്കുന്ന സമയം ഉപയോഗിച്ച്, ഒരു വലിയ അളവിലുള്ള ഔട്ട്പുട്ട് നിങ്ങൾ കാണും
ഘട്ടം കാണിച്ചിരിക്കുന്നു (പരാന്തീസിസിൽ മൈക്രോസെക്കൻഡ്). ഉദാഹരണത്തിന്:

xxxx (+0): guestfs_create
xxxx (+29): guestfs_set_pgroup g=0x17a9de0 pgroup=0x1
xxxx (+9): guestfs_add_drive_opts_argv g=0x17a9de0 [...]
xxxx (+8): guestfs_int_safe_strdup g=0x17a9de0 str=0x7f8a153bed5d
xxxx (+19): guestfs_int_safe_malloc g=0x17a9de0 nbytes=0x38
xxxx (+5): guestfs_int_safe_strdup g=0x17a9de0 str=0x17a9f60
xxxx (+10): guestfs_launch g=0x17a9de0
xxxx (+4): ലോഞ്ച്_സ്റ്റാർട്ട്
[തുടങ്ങിയവ]

പൂർണ്ണമായി മനസ്സിലാക്കാൻ libguestfs-ലേക്കുള്ള ഉറവിടം നിങ്ങൾ കൂടിയാലോചിക്കുകയും പരിഷ്ക്കരിക്കുകയും ചെയ്യേണ്ടതുണ്ട്
ഔട്ട്പുട്ട്.

വിശദമായ ഡീബഗ്ഗിംഗ് ഉപയോഗിക്കുന്നു ജിഡിബി

നിങ്ങൾക്ക് gdb ഉപയോഗിച്ച് അപ്ലയൻസ് ബയോസ്/കേർണലിലേക്ക് അറ്റാച്ചുചെയ്യാം. നിങ്ങൾ എന്താണ് ചെയ്യുന്നതെന്ന് നിങ്ങൾക്കറിയാമെങ്കിൽ,
ബൂട്ട് റിഗ്രഷനുകൾ കണ്ടുപിടിക്കുന്നതിനുള്ള ഒരു ഉപയോഗപ്രദമായ മാർഗ്ഗമാണിത്.

ആദ്യം, നിങ്ങൾ qemu മാറ്റേണ്ടതുണ്ട്, അതിനാൽ ഇത് "-S", "-s" ഓപ്ഷനുകൾ ഉപയോഗിച്ച് പ്രവർത്തിക്കുന്നു. ഈ ഓപ്ഷനുകൾ
ബൂട്ടിൽ qemu താൽക്കാലികമായി നിർത്തുകയും ഒരു ഡീബഗ്ഗർ അറ്റാച്ചുചെയ്യാൻ നിങ്ങളെ അനുവദിക്കുകയും ചെയ്യുന്നു. വായിക്കുക ശ്ശോ(1) കൂടുതൽ കാര്യങ്ങൾക്കായി
വിവരങ്ങൾ. Libguestfs നിരവധി തവണ qemu അഭ്യർത്ഥിക്കുന്നു (സഹായ ഔട്ട്പുട്ട് സ്കാൻ ചെയ്യുന്നതിനും മറ്റും)
ഈ ഓപ്‌ഷനുകൾ ഉപയോഗിക്കുന്നതിന് qemu-ന്റെ അന്തിമ അഭ്യർത്ഥന മാത്രമേ നിങ്ങൾക്ക് ആവശ്യമുള്ളൂ, അതിനാൽ ഒരു qemu റാപ്പർ ഉപയോഗിക്കുക
ഇതുപോലുള്ള സ്ക്രിപ്റ്റ്:

#!/ ബിൻ / ബാഷ് -

# യഥാർത്ഥ qemu ബൈനറിയിലേക്ക് പോയിന്റ് ചെയ്യാൻ ഇത് സജ്ജമാക്കുക.
qemu=/usr/bin/qemu-kvm

എങ്കിൽ [ "$1" != "-global" ]; പിന്നെ
# സഹായ ഔട്ട്‌പുട്ട് മുതലായവ സ്കാൻ ചെയ്യുന്നു.
എക്സിക് $qemu "$@"
മറ്റാരെങ്കിലും
# ശരിക്കും qemu ഓടുന്നു.
എക്സിക് $qemu -S -s "$@"
fi

ഇപ്പോൾ qemu റാപ്പർ ഉപയോഗിച്ച് ഗസ്റ്റ്ഫിഷ് അല്ലെങ്കിൽ മറ്റൊരു libguestfs ടൂൾ പ്രവർത്തിപ്പിക്കുക ("QEMU WRAPPERS" കാണുക
അതിഥികൾ(3) ഇത് എന്താണ് ചെയ്യുന്നതെന്ന് മനസിലാക്കാൻ):

LIBGUESTFS_HV=/path/to/qemu-wrapper guestfish -a /dev/null -v റൺ

qemu ലോഞ്ച് ചെയ്തതിന് ശേഷം ഇത് താൽക്കാലികമായി നിർത്തണം. മറ്റൊരു വിൻഡോയിൽ, gdb ഉപയോഗിച്ച് qemu-ലേക്ക് അറ്റാച്ചുചെയ്യുക:

$ ജിഡിബി
(gdb) സെറ്റ് ആർക്കിടെക്ചർ i8086
ടാർഗെറ്റ് ആർക്കിടെക്ചർ i8086 ആണെന്ന് അനുമാനിക്കപ്പെടുന്നു
(ജിഡിബി) ടാർഗെറ്റ് റിമോട്ട് :1234
:1234 ഉപയോഗിച്ച് വിദൂര ഡീബഗ്ഗിംഗ്
0x0000fff0 in ?? ()
(ജിഡിബി) തുടരുക

ഈ ഘട്ടത്തിൽ നിങ്ങൾക്ക് സ്റ്റാൻഡേർഡ് ജിഡിബി ടെക്നിക്കുകൾ ഉപയോഗിക്കാം, ഉദാ. ബൂട്ട് തടസ്സപ്പെടുത്താൻ "^C" അമർത്തുക
കൂടാതെ "bt" ന് ഒരു സ്റ്റാക്ക് ട്രെയ്സ് നേടുക, ബ്രേക്ക്‌പോയിന്റുകൾ സജ്ജീകരിക്കുക തുടങ്ങിയവ. നിങ്ങൾ കഴിഞ്ഞാൽ അത് ശ്രദ്ധിക്കുക
BIOS-ലും Linux കേർണലിലും, നിങ്ങൾ ആർക്കിടെക്ചർ 32 അല്ലെങ്കിൽ 64 ലേക്ക് മാറ്റണം.
ബിറ്റ്.

onworks.net സേവനങ്ങൾ ഉപയോഗിച്ച് ഗസ്റ്റ്ഫ്സ്-പ്രകടനം ഓൺലൈനായി ഉപയോഗിക്കുക