guestfs-performance - Online sa Cloud

PROGRAMA:

NAME

guestfs-performance - engineering libguestfs para sa pinakamahusay na pagganap

DESCRIPTION

Ang pahinang ito ay nagdodokumento kung paano makuha ang pinakamahusay na pagganap mula sa libguestfs, lalo na kapag
inaasahan mong gumamit ng libguestfs para manipulahin ang libu-libong virtual machine o disk image.

Tatlong pangunahing lugar ang sakop. Ang Libguestfs ay nagpapatakbo ng isang appliance (isang maliit na pamamahagi ng Linux)
sa loob ng qemu/KVM. Ang unang dalawang bahagi ay: pagliit ng oras na ginugol upang simulan ito
appliance, at ang bilang ng beses na kailangang simulan ang appliance. Ang ikatlong lugar ay
paikliin ang oras na kinuha para sa inspeksyon ng mga VM.

BASELINE PANAHON

Bago gumawa ng mga pagbabago sa kung paano mo ginagamit ang libguestfs, kumuha ng mga pagsukat sa baseline.

Baseline: Simula ang kasangkapan
Sa isang diskargado na makina, oras kung gaano katagal bago simulan ang appliance:

time guestfish -a /dev/null run

Patakbuhin ang utos na ito nang maraming beses sa isang hilera at itapon ang unang ilang pagtakbo, upang ikaw ay
pagsukat ng tipikal na "hot cache" case.

Paliwanag

Sinisimulan ng command na ito ang libguestfs appliance sa isang null disk, at pagkatapos ay agad na isinara
pababa ito. Sa unang pagkakataon na patakbuhin mo ang command, lilikha ito ng appliance at i-cache ito
(karaniwan ay nasa ilalim /var/tmp/.guestfs-*). Ang mga kasunod na pagtakbo ay dapat gamitin muli ang naka-cache na appliance.

Inaasahang resulta

Dapat mong asahan na nakakakuha ng mga oras sa ilalim ng 6 na segundo. Kung ang mga oras na nakikita mo sa isang
ang unloaded machine ay nasa itaas nito, pagkatapos ay tingnan ang seksyong "TROUBLESHOOTING POOR PERFORMANCE"
sa ibaba.

Baseline: Nagpapalabas inspeksyon of a bisita
Para sa pagsubok na ito, kakailanganin mo ng isang diskargado na makina at hindi bababa sa isang tunay na bisita o disk image.
Kung nagpaplano kang gumamit ng libguestfs laban sa mga X bisita lamang (hal. X = Windows), pagkatapos ay gamitin
ang isang bisitang X dito ay pinakaangkop. Kung nagpaplano kang magpatakbo ng libguestfs laban sa
isang halo ng mga bisita, pagkatapos ay gumamit ng halo ng mga bisita para sa pagsubok dito.

Oras kung gaano katagal bago magsagawa ng inspeksyon at i-mount ang mga disk ng bisita. Gamitin ang
unang utos kung gagamit ka ng mga imahe sa disk, at ang pangalawang utos kung gagamit ka
gamit ang libvirt.

oras guestfish --ro -a disk.img -i exit

oras guestfish --ro -d GuestName -i exit

Patakbuhin ang command ng ilang beses sa isang hilera at itapon ang unang ilang mga run, upang ikaw ay
pagsukat ng tipikal na "hot cache" case.

Paliwanag

Ang utos na ito ay nagsisimula sa libguestfs appliance sa pinangalanang disk image o libvirt guest,
nagsasagawa ng libguestfs inspeksyon dito (tingnan ang "INSPECTION" sa guestfs(3)), ini-mount ang panauhin
disk, pagkatapos ay itapon ang lahat ng mga resultang ito at isara.

Sa unang pagkakataon na patakbuhin mo ang command, lilikha ito ng appliance at i-cache ito (karaniwan
sa ilalim /var/tmp/.guestfs-*). Ang mga kasunod na pagtakbo ay dapat gamitin muli ang naka-cache na appliance.

Inaasahang resulta

Dapat mong asahan ang mga oras na ≤ 5 segundo na mas malaki kaysa sa sinusukat sa unang baseline
pagsubok sa itaas. (Halimbawa, kung ang unang baseline test ay tumakbo sa loob ng 5 segundo, ang pagsusulit na ito
dapat tumakbo sa ≤ 10 segundo).

NATING ITO ANG PAGLALAPAT AT WHEN IT IS BUILT/CACHED

Sa unang pagkakataon na gumamit ka ng libguestfs, bubuo ito at mag-cache ng appliance. Ito ay kadalasan
in /var/tmp/.guestfs-*, maliban kung nagtakda ka ng $TMPDIR o $LIBGUESTFS_CACHEDIR kung saan
ito ay nasa ilalim ng pansamantalang direktoryo na iyon.

Para sa higit pang impormasyon tungkol sa kung paano ginawa ang appliance, tingnan ang "SUPERMIN APPLIANCES" sa
superminNa (1).

Sa tuwing tatakbo ang libguestfs, susuriin nito na walang mga host file na ginagamit ng appliance
nagbago. Kung mayroon man, itatayo muli ang appliance. Ito ay kadalasang nangyayari kapag ang isang pakete
ay naka-install o na-update sa host (hal. gamit ang mga program tulad ng "yum" o "apt-get"). Ang
ang dahilan ng muling pagtatayo ng appliance ay seguridad: ang bagong programa na
Ang naka-install ay maaaring maglaman ng pag-aayos ng seguridad, at kaya gusto naming isama ang nakapirming programa sa
awtomatikong appliance.

Ito ang mga implikasyon sa pagganap:

· Ang proseso ng pagbuo (o muling pagtatayo) ng naka-cache na appliance ay mabagal, at magagawa mo
iwasang mangyari ito sa pamamagitan ng paggamit ng fixed appliance (tingnan sa ibaba).

· Kung hindi gumagamit ng fixed appliance, magkaroon ng kamalayan na ang pag-update ng software sa host ay magdudulot
isang beses na muling pagtatayo ng appliance.

· / var / tmp (o $TMPDIR, $LIBGUESTFS_CACHEDIR) ay dapat nasa isang mabilis na disk, at maraming
ng espasyo para sa appliance.

GAMIT A NAKAPIRMING PAGLALAPAT

Upang ganap na makontrol kung kailan ginawa ang appliance, maaari kang bumuo ng fixed appliance. Ito
appliance ay dapat na naka-imbak sa isang mabilis na lokal na disk.

Upang buuin ang appliance, patakbuhin ang command:

libguestfs-make-fixed-appliance

pinapalitan" " na may pangalan ng isang direktoryo kung saan iimbak ang appliance
(karaniwan ay magpapangalan ka ng isang subdirectory, halimbawa: /usr/local/lib/guestfs/appliance or
/dev/shm/appliance).

Pagkatapos ay itakda ang $LIBGUESTFS_PATH (at tiyaking nakatakda ang environment variable na ito sa iyong libguestfs
program), o baguhin ang iyong programa upang tawagin nito ang "guestfs_set_path". Halimbawa:

i-export ang LIBGUESTFS_PATH=/usr/local/lib/guestfs/appliance

Ngayon ay maaari ka nang magpatakbo ng mga libguestfs programs, virt tools, guestfish atbp. gaya ng normal. Ang mga programa
ay gagamit ng iyong nakapirming appliance, at hindi kailanman gagawa, muling bubuo, o i-cache ang kanilang sarili
kasangkapan.

(Para sa detalyadong impormasyon sa paksang ito, tingnan ang: libguestfs-make-fixed-appliance(1)).

pagganap of ang maayos kasangkapan
Sa aming pagsubok, hindi namin nakita na ang paggamit ng isang nakapirming appliance ay nagbigay ng anumang masusukat
benepisyo sa pagganap, kahit na ang appliance ay nasa memorya (hal. sa /dev/shm).
Gayunpaman, mayroong dalawang puntos na dapat isaalang-alang:

1. Ang paggamit ng isang nakapirming appliance ay humihinto sa libguestfs na muling itayo ang appliance, ibig sabihin
na ang libguestfs ay magkakaroon ng mas mahuhulaan na oras ng pagsisimula.

2. Ang appliance ay kinakarga kapag hinihiling. Isang simpleng pagsubok tulad ng:

time guestfish -a /dev/null run

hindi masyadong naglo-load ng appliance. Isang tunay na programang libguestfs gamit ang kumplikado
Ang mga tawag sa API ay hihingi ng higit pang pagkarga sa appliance. Ang kakayahang mag-imbak ng
Ang appliance sa isang tinukoy na lokasyon ay ginagawang mas predictable ang performance.

PAGBAWAS ANG NUMBER OF TIMES ANG PAGLALAPAT IS INILUNSAD

Sa ngayon ang pinaka-epektibo, kahit na hindi palaging ang pinakasimpleng paraan upang makakuha ng mahusay na pagganap ay
upang matiyak na ang appliance ay inilunsad sa pinakamababang bilang ng beses. Ito ay malamang
kasangkot ang pagbabago ng iyong libguestfs application.

Subukang tawagan ang "guestfs_launch" nang hindi hihigit sa isang beses sa bawat target na virtual machine o disk image.

Sa halip na gumamit ng hiwalay na halimbawa ng guestfish(1) gumawa ng serye ng mga pagbabago sa
parehong bisita, gumamit ng isang halimbawa ng guestfish at/o gamitin ang guestfish --makinig pagpipilian.

Isaalang-alang ang pagsulat ng iyong programa bilang isang daemon na nagpipigil sa isang bisita habang gumagawa ng isang serye
ng mga pagbabago. O marshal ang lahat ng mga operasyon na gusto mong gawin bago buksan ang bisita.

Maaari mo ring subukang magdagdag ng mga disk mula sa maraming bisita sa isang appliance. Bago subukan
ito, tandaan ang mga sumusunod na punto:

1. Ang pagdaragdag ng maraming bisita sa isang appliance ay isang problema sa seguridad dahil maaari nitong payagan ang isa
bisita upang makagambala sa mga disk ng isa pang bisita. Gawin mo lang kung pinagkakatiwalaan mo ang lahat
mga bisita, o kung maaari mong pangkatin ang mga bisita sa pamamagitan ng pagtitiwala.

2. May mahirap na limitasyon sa bilang ng mga disk na maaari mong idagdag sa isang appliance. Tumawag
"guestfs_max_disks" sa guestfs(3) upang makuha ang limitasyong ito. Para sa karagdagang impormasyon tingnan
"LIMITAS" sa guestfsNa (3).

3. Ang paggamit ng libguestfs sa ganitong paraan ay kumplikado. Maaaring magkaroon ng mga hindi inaasahang pakikipag-ugnayan ang mga disk: para sa
halimbawa, kung dalawang bisita ang gumagamit ng parehong UUID para sa isang filesystem (dahil na-clone sila),
o magkaroon ng mga pangkat ng volume na may parehong pangalan (ngunit tingnan ang "guestfs_lvm_set_filter").

virt-df(1) nagdaragdag ng maramihang mga disk bilang default, kaya ang source code para sa program na ito ay a
magandang lugar para magsimula.

Pagpapaikli ANG TIME KINUHA PARA SA INSPEKSYON OF VMs

Ang pangunahing payo ay halata: Huwag magsagawa ng inspeksyon (na mahal) maliban kung kailangan mo
ang mga resulta.

Kung dati kang nagsagawa ng inspeksyon sa bisita, maaaring ligtas itong i-cache at
muling gamitin ang mga resulta mula sa huling pagkakataon.

Ang ilang mga disk ay hindi kailangang suriin sa lahat: halimbawa, kung ikaw ay gumagawa ng isang disk
larawan, o kung ang disk image ay hindi isang VM, o kung ang disk image ay may kilalang layout.

Kahit na kailangan ang pangunahing inspeksyon ("guestfs_inspect_os"), pantulong na inspeksyon
maaaring iwasan ang mga operasyon:

· Ang pag-mount ng mga disk ay kailangan lamang upang makakuha ng karagdagang impormasyon ng filesystem.

· Ang listahan ng mga application ("guestfs_inspect_list_applications") ay isang mamahaling operasyon
sa Linux, ngunit halos libre sa Windows.

· Ang pagbuo ng icon ng bisita ("guestfs_inspect_get_icon") ay mura sa Linux ngunit mahal
sa Windows.

PARALLEL APLIKASYON

Ang mga appliances ng Libguestfs ay halos I/O bound at maaari kang maglunsad ng maraming appliances
parallel. Kung mayroong sapat na libreng memorya, dapat mayroong maliit na pagkakaiba sa
paglulunsad ng 1 appliance vs N appliances na magkatulad.

Sa isang 2-core (4-thread) na laptop na may 16 GB ng RAM, gamit ang (hindi partikular na makatotohanan) na pagsubok
Perl script sa ibaba, ang sumusunod na plot ay nagpapakita ng mahusay na scalability kapag tumatakbo sa pagitan ng 1
at 20 appliances na magkatulad:

12 ++---+----+----+----+-----+----+----+----+----+-- -++
+ + + + + + + + + + *
| |
| * |
11 ++ ++
| |
| |
| * * |
10 ++ ++
| * |
| |
s | |
9 ++ ++
e | |
| * |
c | |
8 ++ * ++
o | * |
| |
n 7 ++ ++
| * |
d | * |
| |
s 6 ++ ++
| * * |
| * |
| |
5 ++ ++
| |
| * |
| * * |
4 ++ ++
| |
| |
+ * * * + + + + + + + + +
3 ++-*-+----+----+----+-----+----+----+----+----+-- -++
0 2 4 6 8 10 12 14 16 18 20
bilang ng mga parallel appliances

Posibleng magpatakbo ng higit sa 20 appliances nang magkatulad, ngunit kung ginagamit mo ang
libvirt backend pagkatapos ay dapat mong malaman na sa labas ng kahon libvirt nililimitahan ang bilang ng
mga koneksyon ng kliyente sa 20.

Ang simpleng Perl script sa ibaba ay ginamit upang mangolekta ng data para sa plot sa itaas, ngunit mayroon
higit pang impormasyon sa paksang ito, kabilang ang mas advanced na mga script at graph ng pagsubok,
magagamit sa mga sumusunod na pag-post sa blog:

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 perlas

gumamit ng mahigpit;
gumamit ng mga thread;
gumamit ng mga babala;
gamitin ang Sys::Guestfs;
gamitin ang Oras::HiRes qw(oras);

sub test {
my $g = Sys::Guestfs->new;
$g->add_drive_ro ("/dev/null");
$g->launch ();

# Maaari kang magdagdag ng ilang trabaho para sa libguestfs na gawin dito.

$g->close ();
}

# Ilagay ang lahat sa cache.
pagsusulit (); pagsusulit (); pagsusulit ();

para sa aking $nr_threads (1..20) {
aking $start_t = oras ();
aking @mga thread;
foreach (1..$nr_threads) {
push @threads, threads->create (\&test)
}
foreach (@mga thread) {
$_->sumali ();
kung (aking $err = $_->error ()) {
mamatay "bigo ang paglunsad sa $nr_threads na mga thread: $err"
}
}
aking $end_t = oras ();
printf ("%d %.2f\n", $nr_threads, $end_t - $start_t);
}

GAMIT USER-MODE LINUX

Mula noong libguestfs 1.24, naging posible na gamitin ang User-Mode Linux (uml) backend
sa halip na KVM (tingnan ang "USER-MODE LINUX BACKEND" sa guestfs(3)). Ang seksyong ito ay gumagawa ng ilan
pangkalahatang mga komento tungkol sa backend na ito, ngunit ito ay labis ipinapayong upang sukatin ang iyong sarili
workload sa ilalim ng UML sa halip na magtiwala sa mga komento o intuwisyon.

· Ang UML ay karaniwang gumaganap ng pareho o bahagyang mas mabagal kaysa sa KVM, sa baremetal.

· Gayunpaman madalas na gumaganap ang UML sa ilalim ng virtualization tulad ng ginagawa nito sa baremetal,
samantalang ang KVM ay maaaring tumakbo nang mas mabagal sa ilalim ng virtualization (dahil ang hardware virt acceleration
ay hindi magagamit).

· Ang pag-upload at pag-download ay 10 beses na mas mabagal sa UML kaysa sa KVM. Nagpapadala ang Libguestfs
ang data na ito sa ibabaw ng UML emulated serial port, na hindi gaanong mahusay kaysa sa KVM's
virtio-serial.

· Kulang ang UML ng ilang feature (hal. suporta sa qcow2), kaya maaaring hindi ito naaangkop.

Para sa ilang aktwal na figure, tingnan ang:
http://rwmj.wordpress.com/2013/08/14/performance-of-user-mode-linux-as-a-libguestfs-backend/#galang

Pag-areglo MAHIRAP PAGGANAP

Matiyak hardware virtualization is magagamit
paggamit / proc / cpuinfo at ang pahinang ito:

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

upang matiyak na magagamit ang virtualization ng hardware. Tandaan na maaaring kailanganin mong paganahin ito
sa iyong BIOS.

Ang hardware virt ay karaniwang hindi available sa loob ng mga VM, at ang libguestfs ay dahan-dahang tatakbo sa loob
isa pang virtual machine kahit anong gawin mo. Hindi gumagana nang maayos ang nested virtualization sa aming
karanasan, at tiyak na walang kapalit sa pagpapatakbo ng libguestfs sa baremetal.

Matiyak KVM is magagamit
Tiyaking naka-enable at available ang KVM sa user na tatakbo sa libguestfs. Dapat
maging ligtas na itakda ang 0666 na mga pahintulot sa /dev/kvm at karamihan sa mga pamamahagi ngayon ay ginagawa ito.

Processor sa iwasan
Iwasan ang mga processor na walang virtualization ng hardware, at ilang processor na mayroon
napakabagal lang (ang AMD Geode ay isang magandang halimbawa).

Xen dom0
Sa Xen, ang dom0 ay isang virtual machine, kaya hindi available ang virtualization ng hardware.

DETALYE PANAHON GAMIT TS

Gamitin ang ts(1) utos (mula sa moreutils) upang ipakita ang mga detalyadong timing:

$ guestfish -a /dev/null run -v |& ts -i '%.s'
0.000022 libguestfs: launch: program=guestfish
0.000134 libguestfs: launch: version=1.29.31fedora=23,release=2.fc23,libvirt
0.000044 libguestfs: launch: backend registered: unix
0.000035 libguestfs: launch: backend registered: uml
0.000035 libguestfs: launch: backend registered: libvirt
0.000032 libguestfs: launch: backend registered: direct
0.000030 libguestfs: launch: backend=libvirt
0.000031 libguestfs: paglunsad: tmpdir=/tmp/libguestfsw18rBQ
0.000029 libguestfs: launch: umask=0002
0.000031 libguestfs: paglunsad: euid=1000
0.000030 libguestfs: bersyon ng libvirt = 1002012 (1.2.12)
[atbp]

Ang mga timestamp ay segundo (paunti-unti mula noong nakaraang linya).

DETALYE PANAHON GAMIT SYSTEMTAP

Maaari mong gamitin ang SystemTap (stap(1)) upang makakuha ng mga detalyadong timing mula sa mga programa ng libguestfs.

I-save ang sumusunod na script bilang oras.stap:

pandaigdigang huling;

function display_time () {
ngayon = gettimeofday_us ();
delta = 0;
kung (huling > 0)
delta = ngayon - huling;
huling = ngayon;

printf ("%d (+%d):", ngayon, delta);
}

simulan ang pagsisiyasat {
huling = 0;
printf ("ready\n");
}

/* Ipakita ang lahat ng mga tawag sa mga static na marker. */
proseso ng pagsisiyasat ("/ Usr / lib*/libguestfs.so.0")
.provider("guestfs").mark("*") ? {
display_time();
printf ("\t%s %s\n", $$pangalan, $$parms);
}

/* Ipakita ang lahat ng mga tawag sa guestfs_* function. */
proseso ng pagsisiyasat ("/ Usr / lib*/libguestfs.so.0")
.function("guestfs_[az]*") ? {
display_time();
printf ("\t%s %s\n", probefunc(), $$parms);
}

Patakbuhin ito bilang ugat sa isang window:

# stap time.stap
nakahanda

Nagpi-print ito ng "handa" kapag na-load ng SystemTap ang program. Patakbuhin ang iyong libguestfs program,
guestfish o isang virt tool sa isa pang window. Halimbawa:

$ guestfish -a /dev/null run

Sa stap window makikita mo ang isang malaking halaga ng output, na may oras na kinuha para sa bawat isa
hakbang na ipinakita (microseconds sa panaklong). Halimbawa:

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): launch_start
[atbp]

Kakailanganin mong kumonsulta, at kahit na baguhin, ang pinagmulan sa libguestfs upang lubos na maunawaan
ang output.

DETALYE NAG-DEBUGG GAMIT GDB

Maaari kang mag-attach sa BIOS/kernel ng appliance gamit ang gdb. Kung alam mo ang iyong ginagawa,
maaari itong maging isang kapaki-pakinabang na paraan upang masuri ang mga regression ng boot.

Una, kailangan mong baguhin ang qemu para tumakbo ito kasama ang mga opsyon na "-S" at "-s". Ang mga pagpipiliang ito
maging sanhi ng qemu na i-pause sa boot at payagan kang mag-attach ng debugger. Basahin qemu(1) para sa karagdagang
impormasyon. Ang Libguestfs ay humihiling ng qemu nang maraming beses (upang i-scan ang output ng tulong at iba pa)
at gusto mo lang ang huling invocation ng qemu na gamitin ang mga opsyong ito, kaya gumamit ng qemu wrapper
script na ganito:

#!/ basahan / bash -

# Itakda ito upang tumuro sa tunay na qemu binary.
qemu=/usr/bin/qemu-kvm

kung [ "$1" != "-global" ]; pagkatapos
# Pag-scan ng output ng tulong atbp.
exec $qemu "$@"
iba
# Talagang tumatakbo ang qemu.
exec $qemu -S -s "$@"
fi

Ngayon patakbuhin ang guestfish o isa pang libguestfs tool gamit ang qemu wrapper (tingnan ang "QEMU WRAPPERS" sa
guestfs(3) upang maunawaan kung ano ang ginagawa nito):

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

Dapat itong i-pause pagkatapos lamang na ilunsad ang qemu. Sa isa pang window, i-attach sa qemu gamit ang gdb:

$ gdb
(gdb) itakda ang arkitektura i8086
Ang target na arkitektura ay ipinapalagay na i8086
(gdb) target remote :1234
Remote debugging gamit ang :1234
0x0000fff0 sa ?? ()
(gdb) cont

Sa puntong ito maaari kang gumamit ng mga karaniwang pamamaraan ng gdb, hal. pagpindot sa "^C" upang matakpan ang boot
at "bt" makakuha ng stack trace, pagtatakda ng mga breakpoint, atbp. Tandaan na kapag nalampasan mo na ang
BIOS at sa Linux kernel, gugustuhin mong baguhin ang arkitektura pabalik sa 32 o 64
bit.

Gumamit ng guestfs-performance online gamit ang mga serbisyo ng onworks.net