ນີ້ແມ່ນຄໍາສັ່ງ guestfs-performance ທີ່ສາມາດດໍາເນີນການໄດ້ໃນ OnWorks ຜູ້ໃຫ້ບໍລິການໂຮດຕິ້ງຟຣີໂດຍໃຊ້ຫນຶ່ງໃນຫຼາຍໆບ່ອນເຮັດວຽກອອນໄລນ໌ຂອງພວກເຮົາເຊັ່ນ Ubuntu Online, Fedora Online, Windows online emulator ຫຼື MAC OS online emulator
ໂຄງການ:
NAME
guestfs-performance - engineering libguestfs ສໍາລັບການປະຕິບັດທີ່ຍິ່ງໃຫຍ່ທີ່ສຸດ
ລາຍລະອຽດ
ຫນ້ານີ້ເອກະສານວິທີການທີ່ຈະໄດ້ຮັບການປະຕິບັດທີ່ຍິ່ງໃຫຍ່ທີ່ສຸດຂອງ libguestfs, ໂດຍສະເພາະໃນເວລາທີ່
ທ່ານຄາດວ່າຈະໃຊ້ libguestfs ເພື່ອຈັດການເຄື່ອງ virtual ຫຼືຮູບດິສກ໌ຫຼາຍພັນເຄື່ອງ.
ສາມພື້ນທີ່ຕົ້ນຕໍແມ່ນກວມເອົາ. Libguestfs ແລ່ນເຄື່ອງໃຊ້ (ການແຈກຢາຍ Linux ຂະໜາດນ້ອຍ)
ພາຍໃນ qemu/KVM. ສອງຂົງເຂດທໍາອິດແມ່ນ: ການຫຼຸດຜ່ອນທີ່ໃຊ້ເວລາທີ່ໃຊ້ເວລາເພື່ອເລີ່ມຕົ້ນການນີ້
ເຄື່ອງໃຊ້, ແລະຈໍານວນເວລາທີ່ເຄື່ອງໃຊ້ຕ້ອງໄດ້ເລີ່ມຕົ້ນ. ພື້ນທີ່ທີສາມແມ່ນ
ຫຼຸດຜ່ອນເວລາໃນການກວດກາ VMs.
ພື້ນຖານ ມາດຕະຖານ
ກ່ອນທີ່ຈະປ່ຽນແປງວິທີທີ່ທ່ານໃຊ້ libguestfs, ໃຊ້ການວັດແທກພື້ນຖານ.
ພື້ນຖານ: ເລີ່ມຕົ້ນ ໄດ້ ເຄື່ອງໃຊ້ໄຟຟ້າ
ໃນເຄື່ອງທີ່ບໍ່ໄດ້ໂຫຼດ, ມັນໃຊ້ເວລາດົນປານໃດເພື່ອເລີ່ມຕົ້ນເຄື່ອງໃຊ້:
time guestfish -a /dev/null run
ດໍາເນີນການຄໍາສັ່ງນີ້ຫຼາຍຄັ້ງຕິດຕໍ່ກັນແລະຍົກເລີກການແລ່ນສອງສາມຄັ້ງທໍາອິດ, ດັ່ງນັ້ນທ່ານ
ການວັດແທກກໍລະນີ "hot cache" ປົກກະຕິ.
ຄໍາອະທິບາຍ
ຄຳສັ່ງນີ້ເລີ່ມເຄື່ອງໃຊ້ libguestfs ຢູ່ໃນແຜ່ນ null, ແລະຫຼັງຈາກນັ້ນປິດທັນທີ
ມັນລົງ. ຄັ້ງທໍາອິດທີ່ທ່ານດໍາເນີນການຄໍາສັ່ງ, ມັນຈະສ້າງອຸປະກອນແລະ cache ມັນ
(ປົກກະຕິແລ້ວພາຍໃຕ້ /var/tmp/.guestfs-*). ການແລ່ນຄັ້ງຕໍ່ໄປຄວນໃຊ້ອຸປະກອນທີ່ເກັບໄວ້ໃນບ່ອນເກັບຂໍ້ມູນຄືນໃໝ່.
ຄາດຫວັງວ່າ ຜົນການຄົ້ນຫາ
ທ່ານຄວນຄາດຫວັງວ່າຈະໄດ້ຮັບເວລາຫນ້ອຍກວ່າ 6 ວິນາທີ. ຖ້າເວລາທີ່ທ່ານເຫັນຢູ່ໃນ
ເຄື່ອງ unloaded ແມ່ນຂ້າງເທິງນີ້, ຫຼັງຈາກນັ້ນເບິ່ງພາກ "ການແກ້ໄຂບັນຫາການປະຕິບັດທີ່ບໍ່ດີ"
ຂ້າງລຸ່ມນີ້.
ພື້ນຖານ: ການປະຕິບັດ ການກວດກາ of a ບຸກຄົນທົ່ວໄປ
ສໍາລັບການທົດສອບນີ້, ທ່ານຈະຕ້ອງການເຄື່ອງ unloaded ແລະຢ່າງຫນ້ອຍຫນຶ່ງແຂກທີ່ແທ້ຈິງຫຼືຮູບພາບແຜ່ນ.
ຖ້າທ່ານກໍາລັງວາງແຜນທີ່ຈະໃຊ້ libguestfs ຕໍ່ກັບແຂກ X ເທົ່ານັ້ນ (ຕົວຢ່າງ. X = Windows), ຫຼັງຈາກນັ້ນໃຊ້
ແຂກ X ຢູ່ທີ່ນີ້ຈະເຫມາະສົມທີ່ສຸດ. ຖ້າທ່ານກໍາລັງວາງແຜນທີ່ຈະດໍາເນີນການ libguestfs ຕໍ່
ການປະສົມຂອງແຂກ, ຫຼັງຈາກນັ້ນໃຊ້ການປະສົມຂອງແຂກສໍາລັບການທົດສອບຢູ່ທີ່ນີ້.
ໃຊ້ເວລາດົນປານໃດເພື່ອດໍາເນີນການກວດກາ ແລະຕິດແຜ່ນຂອງແຂກ. ໃຊ້
ຄໍາສັ່ງທໍາອິດຖ້າຫາກວ່າທ່ານຈະຖືກນໍາໃຊ້ຮູບພາບແຜ່ນ, ແລະຄໍາສັ່ງທີສອງຖ້າຫາກວ່າທ່ານຈະເປັນ
ໃຊ້ libvirt.
time guestfish --ro -a disk.img -i ອອກ
time guestfish --ro -d GuestName -i ອອກ
ດໍາເນີນການຄໍາສັ່ງຫຼາຍຄັ້ງຕິດຕໍ່ກັນແລະຍົກເລີກການແລ່ນສອງສາມຄັ້ງທໍາອິດ, ດັ່ງນັ້ນທ່ານ
ການວັດແທກກໍລະນີ "hot cache" ປົກກະຕິ.
ຄໍາອະທິບາຍ
ຄໍາສັ່ງນີ້ເລີ່ມຕົ້ນອຸປະກອນ libguestfs ຢູ່ໃນຮູບພາບແຜ່ນທີ່ມີຊື່ຫຼືແຂກ libvirt,
ດໍາເນີນການກວດກາ libguestfs ກ່ຽວກັບມັນ (ເບິ່ງ "INSPECTION" ໃນ ແຂກ(3)), mounts ຂອງແຂກ
ແຜ່ນ, ຫຼັງຈາກນັ້ນຍົກເລີກຜົນໄດ້ຮັບທັງຫມົດເຫຼົ່ານີ້ແລະປິດລົງ.
ຄັ້ງທໍາອິດທີ່ທ່ານດໍາເນີນການຄໍາສັ່ງ, ມັນຈະສ້າງອຸປະກອນແລະ cache ມັນ (ປົກກະຕິແລ້ວ
ພາຍໃຕ້ການ /var/tmp/.guestfs-*). ການແລ່ນຄັ້ງຕໍ່ໄປຄວນໃຊ້ອຸປະກອນທີ່ເກັບໄວ້ໃນບ່ອນເກັບຂໍ້ມູນຄືນໃໝ່.
ຄາດຫວັງວ່າ ຜົນການຄົ້ນຫາ
ທ່ານຄວນຄາດຫວັງເວລາທີ່ມີ ≤ 5 ວິນາທີຫຼາຍກວ່າການວັດແທກຢູ່ໃນເສັ້ນພື້ນຖານທໍາອິດ
ການທົດສອບຂ້າງເທິງ. (ຕົວຢ່າງ, ຖ້າການທົດສອບພື້ນຖານຄັ້ງທໍາອິດແລ່ນໃນ 5 ວິນາທີ, ຫຼັງຈາກນັ້ນການທົດສອບນີ້
ຄວນແລ່ນໃນ ≤ 10 ວິນາທີ).
ຄວາມເຂົ້າໃຈ ການ ປະຕິບັດ ແລະ ເມື່ອໃດ IT IS BUILT/CACHED
ຄັ້ງທໍາອິດທີ່ທ່ານໃຊ້ libguestfs, ມັນຈະສ້າງແລະ cache ເຄື່ອງໃຊ້. ນີ້ແມ່ນປົກກະຕິແລ້ວ
in /var/tmp/.guestfs-*, ເວັ້ນເສຍແຕ່ວ່າທ່ານໄດ້ຕັ້ງ $TMPDIR ຫຼື $LIBGUESTFS_CACHEDIR ໃນກໍລະນີໃດ
ມັນຈະຢູ່ພາຍໃຕ້ບັນຊີຊົ່ວຄາວນັ້ນ.
ສໍາລັບຂໍ້ມູນເພີ່ມເຕີມກ່ຽວກັບວິທີການກໍ່ສ້າງອຸປະກອນ, ເບິ່ງ "SUPERMIN APPLIANCES" ໃນ
ຊຸບເປີມິນ(1).
ທຸກໆຄັ້ງທີ່ libguestfs ແລ່ນມັນຈະກວດເບິ່ງວ່າບໍ່ມີໄຟລ໌ໂຮດທີ່ໃຊ້ໂດຍເຄື່ອງໃຊ້
ປ່ຽນແປງ. ຖ້າມີ, ຫຼັງຈາກນັ້ນເຄື່ອງໃຊ້ໄດ້ຖືກສ້າງໃຫມ່. ນີ້ມັກຈະເກີດຂຶ້ນໃນເວລາທີ່ຊຸດ
ໄດ້ຖືກຕິດຕັ້ງຫຼືປັບປຸງຢູ່ໃນໂຮດ (ເຊັ່ນ: ການນໍາໃຊ້ໂຄງການເຊັ່ນ "yum" ຫຼື "apt-get"). ໄດ້
ເຫດຜົນສໍາລັບການ reconstructing ເຄື່ອງໃຊ້ແມ່ນຄວາມປອດໄພ: ໂຄງການໃຫມ່ທີ່ໄດ້
ການຕິດຕັ້ງອາດຈະມີການແກ້ໄຂຄວາມປອດໄພ, ແລະດັ່ງນັ້ນພວກເຮົາຕ້ອງການທີ່ຈະລວມເອົາໂຄງການຄົງທີ່ໃນ
ເຄື່ອງໃຊ້ອັດຕະໂນມັດ.
ນີ້ແມ່ນຜົນສະທ້ອນຂອງການປະຕິບັດ:
· ຂະບວນການຂອງການກໍ່ສ້າງ (ຫຼືການສ້າງໃຫມ່) ເຄື່ອງໃຊ້ໃນຖານຄວາມຈໍາແມ່ນຊ້າ, ແລະທ່ານສາມາດເຮັດໄດ້
ຫຼີກເວັ້ນການນີ້ເກີດຂຶ້ນໂດຍການນໍາໃຊ້ອຸປະກອນຄົງທີ່ (ເບິ່ງຂ້າງລຸ່ມນີ້).
· ຖ້າຫາກວ່າບໍ່ໄດ້ນໍາໃຊ້ອຸປະກອນຄົງທີ່, ຮັບຮູ້ວ່າການປັບປຸງຊອບແວກ່ຽວກັບແມ່ຂ່າຍຈະເຮັດໃຫ້ເກີດ
ການກໍ່ສ້າງເຄື່ອງໃຊ້ໃນຄັ້ງດຽວ.
· / var / tmp (ຫຼື $TMPDIR, $LIBGUESTFS_CACHEDIR) ຄວນຈະຢູ່ໃນຈານດ່ວນ, ແລະມີຫຼາຍຢ່າງ.
ພື້ນທີ່ສໍາລັບເຄື່ອງໃຊ້.
ການ ນຳ ໃຊ້ A FIXED ປະຕິບັດ
ເພື່ອຄວບຄຸມຢ່າງສົມບູນເມື່ອເຄື່ອງໃຊ້ໄດ້ຖືກສ້າງ, ທ່ານສາມາດສ້າງເຄື່ອງໃຊ້ຄົງທີ່. ນີ້
ເຄື່ອງໃຊ້ຄວນຖືກເກັບໄວ້ໃນແຜ່ນທີ່ໄວ.
ເພື່ອສ້າງອຸປະກອນ, ດໍາເນີນການຄໍາສັ່ງ:
libguestfs-make-fixed-appliance
ແທນ " " ດ້ວຍຊື່ຂອງໄດເລກະທໍລີທີ່ເຄື່ອງໃຊ້ຈະຖືກເກັບໄວ້
(ປົກກະຕິທ່ານຈະຕັ້ງຊື່ຍ່ອຍຍ່ອຍ, ຕົວຢ່າງ: /usr/local/lib/guestfs/appliance or
/dev/shm/ເຄື່ອງໃຊ້).
ຈາກນັ້ນຕັ້ງ $LIBGUESTFS_PATH (ແລະໃຫ້ແນ່ໃຈວ່າຕົວແປສະພາບແວດລ້ອມນີ້ຖືກຕັ້ງໄວ້ໃນ libguestfs ຂອງທ່ານ.
program), ຫຼືດັດແປງໂຄງການຂອງທ່ານເພື່ອໃຫ້ມັນເອີ້ນວ່າ "guestfs_set_path". ຍົກຕົວຢ່າງ:
ສົ່ງອອກ LIBGUESTFS_PATH=/usr/local/lib/guestfs/appliance
ໃນປັດຈຸບັນທ່ານສາມາດດໍາເນີນໂຄງການ libguestfs, ເຄື່ອງມື virt, guestfish ແລະອື່ນໆຕາມປົກກະຕິ. ບັນດາໂຄງການ
ຈະໃຊ້ເຄື່ອງໃຊ້ຄົງທີ່ຂອງເຈົ້າ, ແລະຈະບໍ່ສ້າງ, ສ້າງໃຫມ່, ຫຼື cache ຂອງຕົນເອງ
ເຄື່ອງໃຊ້ໄຟຟ້າ.
(ສໍາລັບລາຍລະອຽດກ່ຽວກັບເລື່ອງນີ້, ເບິ່ງ: libguestfs-make-fixed-appliance(1)).
ການປະຕິບັດ of ໄດ້ ຄົງ ເຄື່ອງໃຊ້ໄຟຟ້າ
ໃນການທົດສອບຂອງພວກເຮົາພວກເຮົາບໍ່ໄດ້ພົບເຫັນວ່າການນໍາໃຊ້ອຸປະກອນຄົງທີ່ໃຫ້ການວັດແທກໃດຫນຶ່ງ
ຜົນປະໂຫຍດປະສິດທິພາບ, ເຖິງແມ່ນວ່າໃນເວລາທີ່ອຸປະກອນຢູ່ໃນຫນ່ວຍຄວາມຈໍາ (ie. on /dev/shm).
ຢ່າງໃດກໍຕາມ, ມີສອງຈຸດທີ່ຈະພິຈາລະນາ:
1. ການນໍາໃຊ້ເຄື່ອງໃຊ້ຄົງທີ່ຢຸດ libguestfs ຈາກການສ້າງເຄື່ອງໃຊ້ຄືນໃຫມ່, ຊຶ່ງຫມາຍຄວາມວ່າ
ວ່າ libguestfs ຈະມີເວລາເລີ່ມຕົ້ນທີ່ຄາດເດົາໄດ້ຫຼາຍຂຶ້ນ.
2. ເຄື່ອງໃຊ້ໄດ້ຖືກໂຫຼດຕາມຄວາມຕ້ອງການ. ການທົດສອບງ່າຍດາຍເຊັ່ນ:
time guestfish -a /dev/null run
ບໍ່ໄດ້ໂຫຼດອຸປະກອນຫຼາຍ. ໂຄງການ libguestfs ທີ່ແທ້ຈິງໂດຍໃຊ້ຄວາມສັບສົນ
ການໂທ API ຈະຮຽກຮ້ອງໃຫ້ມີການໂຫຼດອຸປະກອນຫຼາຍ. ຄວາມສາມາດໃນການເກັບຮັກສາ
ເຄື່ອງໃຊ້ໃນສະຖານທີ່ທີ່ລະບຸໄວ້ເຮັດໃຫ້ປະສິດທິພາບສາມາດຄາດເດົາໄດ້ຫຼາຍຂຶ້ນ.
ການຫຼຸດຜ່ອນ ການ NUMBER OF TIMES ການ ປະຕິບັດ IS ເປີດຕົວ
ມາຮອດປະຈຸ, ປະສິດທິຜົນທີ່ສຸດ, ເຖິງແມ່ນວ່າບໍ່ແມ່ນວິທີງ່າຍດາຍທີ່ສຸດເພື່ອໃຫ້ໄດ້ຜົນດີ
ເພື່ອຮັບປະກັນວ່າເຄື່ອງໃຊ້ໄດ້ຖືກເປີດຢູ່ໃນຈໍານວນເວລາຕໍາ່ສຸດທີ່. ນີ້ອາດຈະເປັນ
ມີສ່ວນຮ່ວມໃນການປ່ຽນແປງຄໍາຮ້ອງສະຫມັກ libguestfs ຂອງທ່ານ.
ພະຍາຍາມໂທຫາ "guestfs_launch" ຫຼາຍທີ່ສຸດຫນຶ່ງຄັ້ງຕໍ່ເຄື່ອງ virtual ເປົ້າຫມາຍຫຼືຮູບພາບແຜ່ນ.
ແທນທີ່ຈະໃຊ້ຕົວຢ່າງແຍກຕ່າງຫາກຂອງ ປາແຂກ(1) ເພື່ອເຮັດໃຫ້ຊຸດຂອງການປ່ຽນແປງຂອງ
ແຂກຄົນດຽວກັນ, ໃຊ້ປາຕົວດຽວຂອງ guestfish ແລະ/ຫຼືໃຊ້ guestfish --ຟັງ ທາງເລືອກ.
ພິຈາລະນາການຂຽນໂປຼແກຼມຂອງເຈົ້າເປັນ daemon ທີ່ເປີດແຂກໃນຂະນະທີ່ສ້າງຊຸດ
ຂອງການປ່ຽນແປງ. ຫຼື marshal ການດໍາເນີນງານທັງຫມົດທີ່ທ່ານຕ້ອງການທີ່ຈະປະຕິບັດກ່ອນທີ່ຈະເປີດບຸກຄົນທົ່ວໄປ.
ນອກນັ້ນທ່ານຍັງສາມາດລອງເພີ່ມແຜ່ນຈາກແຂກຫຼາຍໆຄົນໃສ່ເຄື່ອງດຽວ. ກ່ອນທີ່ຈະພະຍາຍາມ
ນີ້, ໃຫ້ສັງເກດຈຸດດັ່ງຕໍ່ໄປນີ້:
1. ການເພີ່ມແຂກຫຼາຍໆຄົນໃສ່ເຄື່ອງໜຶ່ງແມ່ນເປັນບັນຫາດ້ານຄວາມປອດໄພ ເພາະມັນອາດຈະເຮັດໃຫ້ຄົນດຽວໄດ້
ແຂກທີ່ຈະແຊກແຊງແຜ່ນຂອງແຂກອື່ນ. ພຽງແຕ່ເຮັດມັນຖ້າທ່ານໄວ້ວາງໃຈທັງຫມົດ
ແຂກ, ຫຼືຖ້າທ່ານສາມາດຈັດກຸ່ມແຂກໂດຍຄວາມໄວ້ວາງໃຈ.
2. ມີຂໍ້ຈໍາກັດທີ່ຍາກຕໍ່ກັບຈໍານວນແຜ່ນທີ່ທ່ານສາມາດເພີ່ມໃສ່ເຄື່ອງດຽວ. ໂທ
"guestfs_max_disks" ໃນ ແຂກ(3) ເພື່ອໃຫ້ໄດ້ຮັບຂອບເຂດຈໍາກັດນີ້. ສໍາລັບຂໍ້ມູນເພີ່ມເຕີມເບິ່ງ
"LIMITS" ໃນ ແຂກ(3).
3. ການນໍາໃຊ້ libguestfs ວິທີການນີ້ແມ່ນສັບສົນ. ແຜ່ນສາມາດມີການໂຕ້ຕອບທີ່ບໍ່ຄາດຄິດ: ສໍາລັບ
ຕົວຢ່າງ, ຖ້າແຂກສອງຄົນໃຊ້ UUID ດຽວກັນສໍາລັບລະບົບໄຟລ໌ (ເພາະວ່າພວກເຂົາຖືກໂຄນ),
ຫຼືມີກຸ່ມປະລິມານທີ່ມີຊື່ດຽວກັນ (ແຕ່ເບິ່ງ "guestfs_lvm_set_filter").
virt-df(1) ເພີ່ມຫຼາຍແຜ່ນໂດຍຄ່າເລີ່ມຕົ້ນ, ດັ່ງນັ້ນລະຫັດແຫຼ່ງສໍາລັບໂຄງການນີ້ຈະເປັນ a
ສະຖານທີ່ທີ່ດີທີ່ຈະເລີ່ມຕົ້ນ.
ຫຍໍ້ ການ ເວລາ ເອົາ FOR ການກວດສອບ OF VMs
ຄໍາແນະນໍາຕົ້ນຕໍແມ່ນຈະແຈ້ງ: ຢ່າດໍາເນີນການກວດກາ (ເຊິ່ງມີລາຄາແພງ) ເວັ້ນເສຍແຕ່ວ່າທ່ານຕ້ອງການ
ຜົນໄດ້ຮັບ.
ຖ້າຫາກວ່າທ່ານໃນເມື່ອກ່ອນໄດ້ປະຕິບັດການກວດກາກ່ຽວກັບບຸກຄົນທົ່ວໄປ, ຫຼັງຈາກນັ້ນມັນອາດຈະມີຄວາມປອດໄພທີ່ຈະ cache ແລະ
ໃຊ້ຄືນຜົນໄດ້ຮັບຈາກຄັ້ງທີ່ຜ່ານມາ.
ບາງແຜ່ນບໍ່ຈໍາເປັນຕ້ອງຖືກກວດກາທັງຫມົດ: ຕົວຢ່າງ, ຖ້າທ່ານກໍາລັງສ້າງແຜ່ນ
ຮູບພາບ, ຫຼືຖ້າຫາກວ່າຮູບພາບແຜ່ນບໍ່ແມ່ນ VM, ຫຼືຖ້າຫາກວ່າຮູບພາບແຜ່ນມີຮູບແບບທີ່ຮູ້ຈັກ.
ເຖິງແມ່ນວ່າໃນເວລາທີ່ການກວດສອບພື້ນຖານ ("guestfs_inspect_os") ແມ່ນຈໍາເປັນ, ການກວດກາຊ່ວຍ.
ການດໍາເນີນງານອາດຈະຖືກຫຼີກລ່ຽງ:
· ການຕິດຕັ້ງແຜ່ນແມ່ນພຽງແຕ່ມີຄວາມຈໍາເປັນເພື່ອໃຫ້ໄດ້ຮັບຂໍ້ມູນລະບົບໄຟລ໌ເພີ່ມເຕີມ.
· ລາຍຊື່ແອັບພລິເຄຊັນ ("guestfs_inspect_list_applications") ແມ່ນການດໍາເນີນງານລາຄາແພງ
ໃນ Linux, ແຕ່ເກືອບບໍ່ເສຍຄ່າໃນ Windows.
· ການສ້າງໄອຄອນແຂກ ("guestfs_inspect_get_icon") ແມ່ນລາຄາຖືກໃນ Linux ແຕ່ລາຄາແພງ.
ໃນ Windows.
ພາຣາກອດ ການສະ ໝັກ
ເຄື່ອງໃຊ້ Libguestfs ສ່ວນຫຼາຍແມ່ນ I/O ຜູກມັດແລະທ່ານສາມາດເປີດເຄື່ອງໃຊ້ຫຼາຍໃນ
ຂະໜານ. ໂດຍສະຫນອງໃຫ້ມີຄວາມຊົງຈໍາຟຣີພຽງພໍ, ມັນຄວນຈະມີຄວາມແຕກຕ່າງກັນພຽງເລັກນ້ອຍ
ການເປີດຕົວ 1 ເຄື່ອງທຽບກັບ N ເຄື່ອງໃຊ້ໃນຂະຫນານ.
ໃນຄອມພິວເຕີໂນດບຸກ 2-core (4-thread) ທີ່ມີ RAM 16 GB, ໂດຍໃຊ້ການທົດສອບ (ບໍ່ແມ່ນຄວາມຈິງໂດຍສະເພາະ)
Perl script ຂ້າງລຸ່ມນີ້, ດິນຕອນຕໍ່ໄປນີ້ສະແດງໃຫ້ເຫັນການຂະຫຍາຍທີ່ດີເລີດໃນເວລາທີ່ແລ່ນລະຫວ່າງ 1
ແລະ 20 ເຄື່ອງໃຊ້ໃນຂະຫນານ:
12 ++---+----+----+----+-----+----+----+----+----+-- -++
+ + + + + + + + + + + + *
| |
| * |
11 ++ ++
| |
| |
| * * |
10 ++ ++
| * |
| |
s | |
9 ++ ++
e | |
| * |
ຄ | |
8++*++
o | * |
| |
n 7 ++
| * |
d | * |
| |
s 6++ ++
| * * |
| * |
| |
5 ++ ++
| |
| * |
| * * |
4 ++ ++
| |
| |
+ * * * + + + + + + + + + + +
3 ++-*-+----+----+----+-----+----+----+----+----+-- -++
0 2 4 6 8 10 12 14 16 18 20
ຈໍານວນຂອງເຄື່ອງໃຊ້ຂະຫນານ
ມັນເປັນໄປໄດ້ທີ່ຈະດໍາເນີນການຫຼາຍກ່ວາ 20 ເຄື່ອງໃຊ້ໃນຂະຫນານ, ແຕ່ຖ້າຫາກວ່າທ່ານກໍາລັງໃຊ້
libvirt backend ຫຼັງຈາກນັ້ນທ່ານຄວນຮູ້ວ່າອອກຈາກກ່ອງ libvirt ຈໍາກັດຈໍານວນຂອງ
ການເຊື່ອມຕໍ່ລູກຄ້າກັບ 20.
ສະຄິບ Perl ງ່າຍດາຍຂ້າງລຸ່ມນີ້ຖືກນໍາໃຊ້ເພື່ອເກັບກໍາຂໍ້ມູນສໍາລັບດິນຕອນຂ້າງເທິງ, ແຕ່ວ່າມີ
ຂໍ້ມູນເພີ່ມເຕີມກ່ຽວກັບເລື່ອງນີ້, ລວມທັງສະຄິບແລະກາຟການທົດສອບແບບພິເສດ,
ມີຢູ່ໃນບົດຄວາມ 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 perl
ໃຊ້ຢ່າງເຄັ່ງຄັດ;
ໃຊ້ກະທູ້;
ການນໍາໃຊ້ຄໍາເຕືອນ;
ໃຊ້ Sys::Guestfs;
ໃຊ້ເວລາ::HiRes qw(ເວລາ);
ການທົດສອບຍ່ອຍ {
ຂອງຂ້ອຍ $g = Sys::Guestfs->ໃໝ່;
$g->add_drive_ro ("/dev/null");
$g->ເປີດຕົວ ();
# ທ່ານສາມາດເພີ່ມບາງວຽກສໍາລັບ libguestfs ທີ່ຈະເຮັດທີ່ນີ້.
$g->ປິດ ();
}
# ເອົາທຸກສິ່ງທຸກຢ່າງເຂົ້າໄປໃນ cache.
ທົດສອບ (); ທົດສອບ (); ທົດສອບ ();
ສໍາລັບ $nr_threads ຂອງຂ້ອຍ (1..20) {
ຂອງຂ້ອຍ $start_t = ເວລາ ();
@ ກະທູ້ຂອງຂ້ອຍ;
foreach (1..$nr_threads) {
push @threads, threads->ສ້າງ (\&test)
}
foreach (@threads) {
$_->ເຂົ້າຮ່ວມ ();
ຖ້າ ($err ຂອງຂ້ອຍ = $_->error ()) {
die "ການເປີດຕົວລົ້ມເຫລວກັບຫົວຂໍ້ $nr_threads: $err"
}
}
ຂອງຂ້ອຍ $end_t = ເວລາ ();
printf("%d %.2f\n", $nr_threads, $end_t - $start_t);
}
ການ ນຳ ໃຊ້ USER-MODE LINUX
ນັບຕັ້ງແຕ່ libguestfs 1.24, ມັນເປັນໄປໄດ້ທີ່ຈະໃຊ້ User-Mode Linux (uml) backend
ແທນ KVM (ເບິ່ງ "USER-MODE LINUX BACKEND" ໃນ ແຂກ(3)). ພາກນີ້ເຮັດໃຫ້ບາງ
ຂໍ້ສັງເກດທົ່ວໄປກ່ຽວກັບ backend ນີ້, ແຕ່ວ່າມັນແມ່ນ ສູງ ສົມຄວນ ການວັດແທກຂອງທ່ານເອງ
ວຽກງານພາຍໃຕ້ UML ແທນທີ່ຈະເຊື່ອຄໍາເຫັນຫຼື intuition.
· UML ປົກກະຕິແລ້ວປະຕິບັດດຽວກັນຫຼືຊ້າກວ່າ KVM ເລັກນ້ອຍ, ໃນ baremetal.
·ຢ່າງໃດກໍ່ຕາມ UML ມັກຈະປະຕິບັດດຽວກັນພາຍໃຕ້ virtualization ຍ້ອນວ່າມັນເຮັດໃນ baremetal,
ໃນຂະນະທີ່ KVM ສາມາດແລ່ນຊ້າລົງຫຼາຍພາຍໃຕ້ virtualization (ນັບຕັ້ງແຕ່ການເລັ່ງຮາດແວ virt
ບໍ່ສາມາດໃຊ້ໄດ້).
· ອັບໂຫຼດແລະດາວໂຫຼດແມ່ນຫຼາຍເທົ່າທີ່ເປັນ 10 ເວລາຊ້າໃນ UML ກ່ວາ KVM. Libguestfs ສົ່ງ
ຂໍ້ມູນນີ້ຜ່ານພອດ serial emulated UML, ເຊິ່ງມີປະສິດທິພາບຫນ້ອຍກວ່າ KVM ຂອງ.
virtio-serial.
· UML ຂາດຄຸນສົມບັດບາງຢ່າງ (ເຊັ່ນ: qcow2 ສະຫນັບສະຫນູນ), ດັ່ງນັ້ນມັນອາດຈະບໍ່ສາມາດໃຊ້ໄດ້ທັງຫມົດ.
ສໍາລັບຕົວເລກຕົວຈິງບາງອັນ, ເບິ່ງ:
http://rwmj.wordpress.com/2013/08/14/performance-of-user-mode-linux-as-a-libguestfs-backend/# ເນື້ອຫາ
TROUBLESHOOTING ຈຸດປະສົງ ຜົນປະໂຫຍດ
ຮັບປະກັນ ຮາດແວ virtualization is ມີ
ການນໍາໃຊ້ / proc / cpuinfo ແລະໜ້ານີ້:
http://virt-tools.org/learning/check-hardware-virt/
ເພື່ອຮັບປະກັນວ່າຮາດແວ virtualization ສາມາດໃຊ້ໄດ້. ໃຫ້ສັງເກດວ່າທ່ານອາດຈະຈໍາເປັນຕ້ອງໄດ້ເປີດໃຊ້ມັນ
ໃນ BIOS ຂອງທ່ານ.
ຮາດແວ virt ມັກຈະບໍ່ມີຢູ່ໃນ VMs, ແລະ libguestfs ຈະເຮັດວຽກຊ້າໆພາຍໃນ
ເຄື່ອງ virtual ອື່ນໃດກໍ່ຕາມທີ່ທ່ານເຮັດ. Nested virtualization ບໍ່ເຮັດວຽກໄດ້ດີໃນຂອງພວກເຮົາ
ປະສົບການ, ແລະແນ່ນອນວ່າບໍ່ມີການທົດແທນສໍາລັບການແລ່ນ libguestfs ໃນ baremetal.
ຮັບປະກັນ KVM is ມີ
ໃຫ້ແນ່ໃຈວ່າ KVM ຖືກເປີດໃຊ້ງານ ແລະສາມາດໃຊ້ໄດ້ກັບຜູ້ໃຊ້ທີ່ຈະດໍາເນີນການ libguestfs. ມັນຄວນ
ປອດໄພໃນການຕັ້ງຄ່າການອະນຸຍາດ 0666 /dev/kvm ແລະການແຈກຢາຍສ່ວນໃຫຍ່ໃນປັດຈຸບັນເຮັດສິ່ງນີ້.
ໂຮງງານຜະລິດ to ຫລີກລ້ຽງ
ຫຼີກເວັ້ນໂປເຊດເຊີທີ່ບໍ່ມີຮາດແວ virtualization, ແລະບາງໂປເຊດເຊີທີ່ມີ
ພຽງແຕ່ຊ້າຫຼາຍ (AMD Geode ເປັນຕົວຢ່າງທີ່ດີ).
ເຊນ dom0
ໃນ Xen, dom0 ແມ່ນເຄື່ອງ virtual, ແລະດັ່ງນັ້ນ hardware virtualization ແມ່ນບໍ່ສາມາດໃຊ້ໄດ້.
ລາຍລະອຽດ ເວລາ ການ ນຳ ໃຊ້ TS
ການນໍາໃຊ້ ts(1) ຄໍາສັ່ງ (ຈາກ moreutils) ເພື່ອສະແດງໃຫ້ເຫັນເວລາລະອຽດ:
$ guestfish -a /dev/null run -v |& ts -i '%.s'
0.000022 libguestfs: launch: program=guestfish
0.000134 libguestfs: ເປີດຕົວ: version=1.29.31fedora=23,release=2.fc23,libvirt
0.000044 libguestfs: launch: backend ລົງທະບຽນ: unix
0.000035 libguestfs: ເປີດຕົວ: backend ລົງທະບຽນ: uml
0.000035 libguestfs: launch: backend ລົງທະບຽນ: libvirt
0.000032 libguestfs: ເປີດຕົວ: backend ລົງທະບຽນ: ໂດຍກົງ
0.000030 libguestfs: launch: 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:
ໂລກສຸດທ້າຍ;
function display_time () {
now = gettimeofday_us ();
delta = 0;
ຖ້າ (ສຸດທ້າຍ > 0)
delta = ໃນປັດຈຸບັນ - ສຸດທ້າຍ;
last = ໃນປັດຈຸບັນ;
printf("%d (+%d):", ໃນປັດຈຸບັນ, delta);
}
ການສືບສວນເລີ່ມຕົ້ນ {
ສຸດທ້າຍ = 0;
printf ("ພ້ອມ\n");
}
/* ສະແດງການໂທທັງໝົດໄປຫາເຄື່ອງໝາຍສະຖິດ. */
ຂະບວນການສືບສວນ ("/ usr / lib*/libguestfs.so.0")
.provider("guestfs").mark("*") ? {
display_time();
printf ("\t%s %s\n", $$name, $$parms);
}
/* ສະແດງການໂທທັງໝົດໄປຫາຟັງຊັນ guestfs_*. */
ຂະບວນການສືບສວນ ("/ usr / lib*/libguestfs.so.0")
.function("guestfs_[az]*") ? {
display_time();
printf ("\t%s %s\n", probefunc(), $$parms);
}
ແລ່ນມັນເປັນຮາກຢູ່ໃນປ່ອງຢ້ຽມດຽວ:
# stap time.stap
ພ້ອມ
ມັນພິມ "ພ້ອມ" ເມື່ອ SystemTap ໄດ້ໂຫລດໂຄງການ. ດໍາເນີນໂຄງການ libguestfs ຂອງທ່ານ,
guestfish ຫຼືເຄື່ອງມື virt ໃນປ່ອງຢ້ຽມອື່ນ. ຍົກຕົວຢ່າງ:
$ guestfish -a /dev/null run
ຢູ່ໃນປ່ອງຢ້ຽມ stap ທ່ານຈະເຫັນເປັນຈໍານວນຂະຫນາດໃຫຍ່ຂອງຜົນຜະລິດ, ໂດຍໃຊ້ເວລາສໍາລັບແຕ່ລະຄົນ
ສະແດງໃຫ້ເຫັນຂັ້ນຕອນ (microseconds ໃນວົງເລັບ). ຍົກຕົວຢ່າງ:
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
[ແລະອື່ນໆ]
ທ່ານຈະຕ້ອງປຶກສາ, ແລະແມ້ກະທັ້ງດັດແກ້, ແຫຼ່ງຂອງ libguestfs ເພື່ອເຂົ້າໃຈຢ່າງເຕັມສ່ວນ
ຜົນຜະລິດ.
ລາຍລະອຽດ ກຳ ລັງດີບັກ ການ ນຳ ໃຊ້ GDB
ທ່ານສາມາດແນບໃສ່ອຸປະກອນ BIOS/kernel ໂດຍໃຊ້ gdb. ຖ້າເຈົ້າຮູ້ວ່າເຈົ້າກໍາລັງເຮັດຫຍັງ,
ນີ້ສາມາດເປັນວິທີທີ່ມີປະໂຫຍດໃນການວິນິດໄສການຖົດຖອຍຂອງ boot.
ກ່ອນອື່ນ ໝົດ, ທ່ານຕ້ອງປ່ຽນ qemu ເພື່ອໃຫ້ມັນແລ່ນດ້ວຍຕົວເລືອກ "-S" ແລະ "-s". ທາງເລືອກເຫຼົ່ານີ້
ເຮັດໃຫ້ qemu ຢຸດຊົ່ວຄາວໃນເວລາ boot ແລະອະນຸຍາດໃຫ້ທ່ານສາມາດແນບ debugger ໄດ້. ອ່ານ whoa(1) ຕໍ່ໄປ
ຂໍ້ມູນ. Libguestfs ເອີ້ນ qemu ຫຼາຍຄັ້ງ (ເພື່ອສະແກນຜົນໄດ້ຮັບການຊ່ວຍເຫຼືອແລະອື່ນໆ)
ແລະທ່ານພຽງແຕ່ຕ້ອງການການຮຽກຮ້ອງສຸດທ້າຍຂອງ qemu ທີ່ຈະນໍາໃຊ້ທາງເລືອກເຫຼົ່ານີ້, ສະນັ້ນໃຫ້ໃຊ້ wrapper qemu
script ແບບນີ້:
#!/ bin / bash -
# ຕັ້ງສິ່ງນີ້ເພື່ອຊີ້ໄປຫາຄູ່ຄູ່ qemu ທີ່ແທ້ຈິງ.
qemu=/usr/bin/qemu-kvm
ຖ້າ [ "$1" != "-global" ]; ແລ້ວ
# ສະແກນການຊ່ວຍເຫຼືອຜົນຜະລິດແລະອື່ນໆ.
exec $qemu "$@"
ອື່ນ
# ແລ່ນ qemu ແທ້ໆ.
exec $qemu -S -s "$@"
fi
ຕອນນີ້ເປີດໃຊ້ guestfish ຫຼືເຄື່ອງມື libguestfs ອື່ນດ້ວຍ qemu wrapper (ເບິ່ງ "QEMU WRAPPERS" ໃນ
ແຂກ(3) ເພື່ອເຂົ້າໃຈສິ່ງທີ່ນີ້ແມ່ນເຮັດໄດ້):
LIBGUESTFS_HV=/path/to/qemu-wrapper guestfish -a /dev/null -v ແລ່ນ
ນີ້ຄວນຈະຢຸດຊົ່ວຄາວຫຼັງຈາກ qemu ເປີດຕົວ. ໃນປ່ອງຢ້ຽມອື່ນ, ຕິດກັບ qemu ໂດຍໃຊ້ gdb:
$ gdb
(gdb) ຊຸດສະຖາປັດຕະຍະກໍາ i8086
ສະຖາປັດຕະຍະກໍາເປົ້າຫມາຍແມ່ນສົມມຸດວ່າ i8086
(gdb) ເປົ້າໝາຍໄລຍະໄກ :1234
ການດີບັກທາງໄກໂດຍໃຊ້: 1234
0x0000ffff0 ໃນ ?? ()
(gdb) ຕໍ່
ໃນຈຸດນີ້ທ່ານສາມາດນໍາໃຊ້ເຕັກນິກ gdb ມາດຕະຖານເຊັ່ນ:. ກົດ "^C" ເພື່ອຂັດຂວາງການບູດ
ແລະ "bt" ໄດ້ຮັບການຕິດຕາມ stack, ກໍານົດ breakpoints, ແລະອື່ນໆ. ໃຫ້ສັງເກດວ່າໃນເວລາທີ່ທ່ານໄດ້ຜ່ານມາ
BIOS ແລະເຂົ້າໄປໃນ Linux kernel, ທ່ານຈະຕ້ອງການປ່ຽນສະຖາປັດຕະຍະກໍາກັບຄືນໄປບ່ອນ 32 ຫຼື 64
bit
ໃຊ້ guestfs-performance ອອນໄລນ໌ໂດຍໃຊ້ບໍລິການ onworks.net
