ໃນລະດູໃບໄມ້ປົ່ງຂອງປີ 2019, ເຫດການທີ່ລໍຄອຍມາດົນນານໄດ້ເກີດຂຶ້ນໃນທີມ Mail.ru Cloud iOS. ຖານຂໍ້ມູນຕົ້ນຕໍສໍາລັບການເກັບຮັກສາຢ່າງຕໍ່ເນື່ອງຂອງລັດຄໍາຮ້ອງສະຫມັກໄດ້ກາຍເປັນ exotic ຫຼາຍສໍາລັບໂລກມືຖື ຖານຂໍ້ມູນທີ່ເຮັດແຜນທີ່ຫນ່ວຍຄວາມຈໍາ Lightning (LMDB). ຂ້າງລຸ່ມນີ້ການຕັດພວກເຮົາສະເຫນີໃຫ້ທ່ານທົບທວນລາຍລະອຽດຂອງມັນຢູ່ໃນສີ່ສ່ວນ. ທໍາອິດ, ໃຫ້ເວົ້າກ່ຽວກັບເຫດຜົນສໍາລັບທາງເລືອກທີ່ບໍ່ເປັນເລື່ອງເລັກນ້ອຍແລະມີຄວາມຫຍຸ້ງຍາກ. ຫຼັງຈາກນັ້ນ, ພວກເຮົາຈະກ້າວໄປຂ້າງຫນ້າເພື່ອພິຈາລະນາສາມເສົາຄໍ້າຢູ່ໃນຈຸດໃຈກາງຂອງສະຖາປັດຕະຍະກໍາ LMDB: ໄຟລ໌ທີ່ມີແຜນທີ່ຫນ່ວຍຄວາມຈໍາ, B+-tree, ວິທີການ copy-on-write ສໍາລັບການປະຕິບັດການເຮັດທຸລະກໍາແລະ multiversion. ສຸດທ້າຍ, ສໍາລັບ dessert - ພາກປະຕິບັດ. ໃນມັນພວກເຮົາຈະເບິ່ງວິທີການອອກແບບແລະປະຕິບັດລະບົບຖານຂໍ້ມູນທີ່ມີຕາຕະລາງຫຼາຍ, ລວມທັງດັດສະນີຫນຶ່ງ, ຢູ່ເທິງສຸດຂອງ API ມູນຄ່າຕ່ໍາລະດັບ.

ເນື້ອໃນ

ແຮງຈູງໃຈໃນການປະຕິບັດ
ການຈັດຕໍາແຫນ່ງ LMDB
ສາມເສົາຄ້ຳຂອງ LMDB
3.1. ປາວານ #1. ໄຟລ໌ທີ່ມີແຜນທີ່ດ້ວຍໜ່ວຍຄວາມຈຳ
3.2. ປາວານ #2. B+-ຕົ້ນໄມ້
3.3. ປາວານ #3. ສຳເນົາ-ຂຽນ
ການອອກແບບໂຄງຮ່າງຂໍ້ມູນຢູ່ເທິງສຸດຂອງ key-value API
4.1. ບົດຄັດຫຍໍ້ພື້ນຖານ
4.2. ການສ້າງແບບຈໍາລອງຕາຕະລາງ
4.3. ການສ້າງແບບຈໍາລອງຄວາມສໍາພັນລະຫວ່າງຕາຕະລາງ

1. ແຮງຈູງໃຈໃນການຈັດຕັ້ງປະຕິບັດ

ຫນຶ່ງປີໃນປີ 2015, ພວກເຮົາໄດ້ເອົາບັນຫາໃນການວັດແທກເລື້ອຍໆວ່າການໂຕ້ຕອບຂອງຄໍາຮ້ອງສະຫມັກຂອງພວກເຮົາຊັກຊ້າ. ພວກເຮົາເຮັດອັນນີ້ດ້ວຍເຫດຜົນ. ພວກເຮົາໄດ້ຮັບການຮ້ອງທຸກເລື້ອຍໆເລື້ອຍໆວ່າບາງຄັ້ງແອັບພລິເຄຊັນຢຸດການຕອບສະຫນອງຕໍ່ການກະທໍາຂອງຜູ້ໃຊ້: ປຸ່ມບໍ່ສາມາດກົດໄດ້, ລາຍຊື່ບໍ່ເລື່ອນ, ແລະອື່ນໆ. ກ່ຽວກັບກົນໄກການວັດແທກ ບອກ ໃນ AvitoTech, ສະນັ້ນໃນທີ່ນີ້ຂ້າພະເຈົ້າໃຫ້ພຽງແຕ່ຄໍາສັ່ງຂອງຕົວເລກ.

ຜົນໄດ້ຮັບການວັດແທກໄດ້ກາຍເປັນອາບນ້ໍາເຢັນສໍາລັບພວກເຮົາ. ມັນໄດ້ຫັນອອກວ່າມີຫຼາຍບັນຫາທີ່ເກີດຈາກ freezes ກ່ວາອື່ນໆ. ຖ້າກ່ອນທີ່ຈະຮັບຮູ້ຄວາມເປັນຈິງນີ້ຕົວຊີ້ວັດດ້ານວິຊາການຕົ້ນຕໍຂອງຄຸນນະພາບແມ່ນບໍ່ມີອຸປະຕິເຫດ, ຫຼັງຈາກນັ້ນຫຼັງຈາກສຸມໃສ່ ປ່ຽນ ໃນ freeze free.

ມີການກໍ່ສ້າງ dashboard ມີ freezes ແລະຫຼັງຈາກການໃຊ້ຈ່າຍ ປະລິມານ и ຄຸນນະພາບ ການວິເຄາະເຫດຜົນຂອງພວກເຂົາ, ສັດຕູຕົ້ນຕໍໄດ້ກາຍເປັນທີ່ຊັດເຈນ - ເຫດຜົນທາງທຸລະກິດຫນັກທີ່ປະຕິບັດຢູ່ໃນກະທູ້ຕົ້ນຕໍຂອງຄໍາຮ້ອງສະຫມັກ. ປະຕິກິລິຍາທໍາມະຊາດຕໍ່ຄວາມເສື່ອມເສີຍນີ້ແມ່ນຄວາມປາຖະຫນາທີ່ຮ້ອນແຮງທີ່ຈະເອົາມັນເຂົ້າໄປໃນສາຍວຽກ. ເພື່ອແກ້ໄຂບັນຫານີ້ຢ່າງເປັນລະບົບ, ພວກເຮົາໄດ້ໃຊ້ສະຖາປັດຕະຍະກຳຫຼາຍເສັ້ນໂດຍອີງໃສ່ນັກສະແດງທີ່ມີນ້ຳໜັກເບົາ. ຂ້ອຍອຸທິດຕົນເພື່ອການປັບຕົວຂອງມັນໃຫ້ກັບໂລກ iOS ສອງກະທູ້ ໃນ Twitter ການລວບລວມແລະ ບົດຄວາມກ່ຽວກັບ Habre. ເປັນສ່ວນຫນຶ່ງຂອງການເທື່ອເນື່ອງຈາກປະຈຸບັນ, ຂ້າພະເຈົ້າຕ້ອງການເນັ້ນຫນັກໃສ່ລັກສະນະເຫຼົ່ານັ້ນຂອງການຕັດສິນໃຈທີ່ມີອິດທິພົນຕໍ່ການເລືອກຖານຂໍ້ມູນ.

ຮູບແບບຕົວລະຄອນຂອງອົງການຈັດຕັ້ງລະບົບຖືວ່າ multithreading ກາຍເປັນຄວາມສໍາຄັນທີສອງຂອງມັນ. ວັດຖຸແບບຈໍາລອງໃນມັນຢາກຈະຂ້າມຂອບເຂດການຖ່າຍທອດ. ແລະເຂົາເຈົ້າເຮັດແນວນີ້ບໍ່ແມ່ນບາງຄັ້ງແລະທີ່ນີ້ແລະທີ່ນັ້ນ, ແຕ່ເກືອບສະເຫມີແລະຢູ່ທົ່ວທຸກແຫ່ງ ..

ຖານຂໍ້ມູນແມ່ນຫນຶ່ງໃນອົງປະກອບພື້ນຖານໃນແຜນວາດທີ່ນໍາສະເຫນີ. ວຽກງານຕົ້ນຕໍຂອງມັນແມ່ນການປະຕິບັດ macropattern ຖານຂໍ້ມູນທີ່ແບ່ງປັນ. ຖ້າຢູ່ໃນໂລກວິສາຫະກິດມັນຖືກນໍາໃຊ້ໃນການຈັດຕັ້ງ synchronization ຂໍ້ມູນລະຫວ່າງການບໍລິການ, ຫຼັງຈາກນັ້ນໃນກໍລະນີຂອງສະຖາປັດຕະຂອງນັກສະແດງ - ຂໍ້ມູນລະຫວ່າງກະທູ້. ດັ່ງນັ້ນ, ພວກເຮົາຕ້ອງການຖານຂໍ້ມູນທີ່ຈະບໍ່ເຮັດໃຫ້ເກີດຄວາມຫຍຸ້ງຍາກຫນ້ອຍທີ່ສຸດໃນເວລາທີ່ເຮັດວຽກກັບມັນໃນສະພາບແວດລ້ອມຫຼາຍກະທູ້. ໂດຍສະເພາະ, ນີ້ຫມາຍຄວາມວ່າວັດຖຸທີ່ໄດ້ຮັບຈາກມັນຕ້ອງມີຢ່າງນ້ອຍປອດໄພ, ແລະໂດຍຫລັກການແລ້ວແມ່ນບໍ່ສາມາດປ່ຽນແປງໄດ້. ຕາມທີ່ທ່ານຮູ້, ຕໍ່ມາສາມາດຖືກນໍາໃຊ້ພ້ອມກັນຈາກຫຼາຍກະທູ້ໂດຍບໍ່ມີການ resorting ກັບ locking ໃດໆ, ເຊິ່ງມີຜົນກະທົບທີ່ເປັນປະໂຫຍດຕໍ່ການປະຕິບັດ.

ປັດໄຈທີ່ສໍາຄັນທີສອງທີ່ມີອິດທິພົນຕໍ່ການເລືອກຖານຂໍ້ມູນແມ່ນ API ຟັງຂອງພວກເຮົາ. ມັນໄດ້ຮັບການດົນໃຈໂດຍວິທີການ synchronization ໄດ້ຮັບຮອງເອົາໂດຍ git. ເຊັ່ນດຽວກັນກັບລາວ, ພວກເຮົາມີຈຸດປະສົງ offline-first API, ເຊິ່ງເບິ່ງຫຼາຍກວ່າທີ່ເຫມາະສົມສໍາລັບລູກຄ້າຟັງ. ມັນໄດ້ຖືກສົມມຸດວ່າພວກເຂົາເຈົ້າພຽງແຕ່ຈະສູບອອກສະຖານະເຕັມຂອງຟັງໄດ້ຫນຶ່ງຄັ້ງ, ແລະຫຼັງຈາກນັ້ນ synchronization ໃນກໍລະນີສ່ວນໃຫຍ່ທີ່ລົ້ນເຫຼືອຈະເກີດຂຶ້ນໂດຍຜ່ານການ rolling ອອກການປ່ຽນແປງ. ອະນິຈາ, ໂອກາດນີ້ຍັງມີພຽງແຕ່ຢູ່ໃນເຂດທິດສະດີ, ແລະລູກຄ້າບໍ່ໄດ້ຮຽນຮູ້ວິທີການເຮັດວຽກກັບແຜ່ນແພໃນການປະຕິບັດ. ມີຫຼາຍເຫດຜົນຈຸດປະສົງສໍາລັບການນີ້, ທີ່, ເພື່ອບໍ່ໃຫ້ຊັກຊ້າການແນະນໍາ, ພວກເຮົາຈະປະໄວ້ທາງຫລັງຂອງວົງເລັບ. ໃນປັດຈຸບັນ, ສິ່ງທີ່ມີຄວາມສົນໃຈຫຼາຍແມ່ນບົດສະຫຼຸບຂອງບົດຮຽນກ່ຽວກັບສິ່ງທີ່ເກີດຂື້ນເມື່ອ API ເວົ້າວ່າ "A" ແລະຜູ້ບໍລິໂພກຂອງມັນບໍ່ໄດ້ເວົ້າວ່າ "B".

ດັ່ງນັ້ນ, ຖ້າທ່ານຈິນຕະນາການ git, ເຊິ່ງ, ເມື່ອປະຕິບັດຄໍາສັ່ງດຶງ, ແທນທີ່ຈະໃຊ້ patches ກັບ snapshot ທ້ອງຖິ່ນ, ປຽບທຽບສະຖານະເຕັມຂອງມັນກັບລັດເຊີຟເວີເຕັມ, ຫຼັງຈາກນັ້ນເຈົ້າຈະມີຄວາມຄິດທີ່ຖືກຕ້ອງກ່ຽວກັບວິທີ synchronization ເກີດຂື້ນໃນ cloud. ລູກຄ້າ. ມັນງ່າຍທີ່ຈະເດົາວ່າເພື່ອປະຕິບັດມັນ, ທ່ານຈໍາເປັນຕ້ອງຈັດສັນສອງຕົ້ນໄມ້ DOM ໃນຫນ່ວຍຄວາມຈໍາທີ່ມີຂໍ້ມູນ meta ກ່ຽວກັບເຄື່ອງແມ່ຂ່າຍແລະໄຟລ໌ທ້ອງຖິ່ນທັງຫມົດ. ມັນປະກົດວ່າຖ້າຜູ້ໃຊ້ເກັບຮັກສາ 500 ພັນໄຟລ໌ຢູ່ໃນເມຄ, ຫຼັງຈາກນັ້ນເພື່ອ synchronize ມັນຈໍາເປັນຕ້ອງສ້າງໃຫມ່ແລະທໍາລາຍຕົ້ນໄມ້ສອງຢ່າງທີ່ມີ 1 ລ້ານ nodes. ແຕ່ແຕ່ລະ node ແມ່ນການລວມກັນທີ່ມີເສັ້ນສະແດງຂອງຫົວຂໍ້ຍ່ອຍ. ໃນຄວາມສະຫວ່າງນີ້, ຜົນໄດ້ຮັບຂອງ profile ຄາດວ່າຈະເປັນ. ມັນໄດ້ຫັນອອກວ່າເຖິງແມ່ນວ່າໂດຍບໍ່ມີການຄໍານຶງເຖິງສູດການລວມ, ຂັ້ນຕອນການສ້າງແລະຕໍ່ມາທໍາລາຍຈໍານວນຂະຫນາດໃຫຍ່ຂອງວັດຖຸຂະຫນາດນ້ອຍຄ່າໃຊ້ຈ່າຍເປັນ penny pretty. ຂອງສະຄຣິບຜູ້ໃຊ້. ດັ່ງນັ້ນ, ພວກເຮົາແກ້ໄຂເງື່ອນໄຂທີ່ສໍາຄັນທີສອງໃນການເລືອກຖານຂໍ້ມູນ - ຄວາມສາມາດໃນການປະຕິບັດການປະຕິບັດ CRUD ໂດຍບໍ່ມີການຈັດສັນແບບເຄື່ອນໄຫວຂອງວັດຖຸ.

ຄວາມຕ້ອງການອື່ນໆແມ່ນແບບດັ້ງເດີມຫຼາຍແລະບັນຊີລາຍຊື່ທັງຫມົດຂອງພວກເຂົາແມ່ນດັ່ງຕໍ່ໄປນີ້.

ຄວາມປອດໄພກະທູ້.
Multiprocessing. dictated ໂດຍຄວາມປາຖະຫນາທີ່ຈະນໍາໃຊ້ຕົວຢ່າງຖານຂໍ້ມູນດຽວກັນເພື່ອ synchronize ສະຖານະບໍ່ພຽງແຕ່ລະຫວ່າງກະທູ້, ແຕ່ຍັງລະຫວ່າງຄໍາຮ້ອງສະຫມັກຕົ້ນຕໍແລະ iOS extensions.
ຄວາມສາມາດທີ່ຈະເປັນຕົວແທນຫນ່ວຍງານທີ່ເກັບຮັກສາໄວ້ເປັນວັດຖຸທີ່ບໍ່ປ່ຽນແປງ ..
ບໍ່ມີການຈັດສັນແບບເຄື່ອນໄຫວພາຍໃນການດໍາເນີນງານ CRUD.
ການສະຫນັບສະຫນູນການເຮັດທຸລະກໍາສໍາລັບຄຸນສົມບັດພື້ນຖານ ເອຊີດີ: ປະລໍາມະນູ, ຄວາມສອດຄ່ອງ, ການໂດດດ່ຽວແລະຄວາມຫນ້າເຊື່ອຖື.
ຄວາມໄວໃນກໍລະນີທີ່ນິຍົມຫຼາຍທີ່ສຸດ.

ດ້ວຍຄວາມຕ້ອງການທີ່ກໍານົດໄວ້ນີ້, SQLite ແມ່ນແລະຍັງເປັນທາງເລືອກທີ່ດີ. ຢ່າງໃດກໍຕາມ, ເປັນສ່ວນຫນຶ່ງຂອງການສຶກສາທາງເລືອກ, ຂ້າພະເຈົ້າໄດ້ພົບຫນັງສື "ການເລີ່ມຕົ້ນດ້ວຍ LevelDB". ພາຍໃຕ້ການນໍາພາຂອງນາງ, ດັດຊະນີໄດ້ຖືກລາຍລັກອັກສອນປຽບທຽບຄວາມໄວຂອງການເຮັດວຽກກັບຖານຂໍ້ມູນທີ່ແຕກຕ່າງກັນໃນສະຖານະການຟັງທີ່ແທ້ຈິງ. ຜົນໄດ້ຮັບເກີນຄວາມຄາດຫວັງຂອງພວກເຮົາ. ໃນກໍລະນີທີ່ນິຍົມຫລາຍທີ່ສຸດ - ການໄດ້ຮັບຕົວກະພິບໃນບັນຊີລາຍຊື່ທີ່ຈັດຮຽງຂອງໄຟລ໌ທັງຫມົດແລະບັນຊີລາຍຊື່ທີ່ຖືກຈັດລຽງຂອງໄຟລ໌ທັງຫມົດສໍາລັບໄດເລກະທໍລີທີ່ໃຫ້ - LMDB ກາຍເປັນ 10 ເທົ່າໄວກວ່າ SQLite. ທາງເລືອກໄດ້ກາຍເປັນທີ່ຊັດເຈນ.

2. ການຈັດຕໍາແໜ່ງ LMDB

LMDB ເປັນຫ້ອງສະຫມຸດຂະຫນາດນ້ອຍຫຼາຍ (ພຽງແຕ່ 10K ແຖວ) ທີ່ປະຕິບັດຊັ້ນພື້ນຖານຕ່ໍາສຸດຂອງຖານຂໍ້ມູນ - ການເກັບຮັກສາ.

ແຜນວາດຂ້າງເທິງສະແດງໃຫ້ເຫັນວ່າການປຽບທຽບ LMDB ກັບ SQLite, ເຊິ່ງຍັງປະຕິບັດລະດັບທີ່ສູງກວ່າ, ໂດຍທົ່ວໄປແລ້ວບໍ່ມີຄວາມຖືກຕ້ອງຫຼາຍກ່ວາ SQLite ກັບ Core Data. ມັນຈະມີຄວາມຍຸຕິທໍາກວ່າທີ່ຈະອ້າງເຖິງເຄື່ອງຈັກການເກັບຮັກສາດຽວກັນກັບຄູ່ແຂ່ງທີ່ເທົ່າທຽມກັນ - BerkeleyDB, LevelDB, Sophia, RocksDB, ແລະອື່ນໆ. ຍັງມີການພັດທະນາທີ່ LMDB ເຮັດຫນ້າທີ່ເປັນອົງປະກອບຂອງເຄື່ອງຈັກໃນການເກັບຮັກສາສໍາລັບ SQLite. ການທົດລອງຄັ້ງທຳອິດແມ່ນໃນປີ 2012 ໃຊ້ຈ່າຍ ໂດຍ LMDB Howard Chu. Результаты ກາຍເປັນສິ່ງທີ່ ໜ້າ ສົນໃຈຫຼາຍທີ່ການລິເລີ່ມຂອງລາວໄດ້ຖືກເກັບຂື້ນໂດຍຜູ້ທີ່ມັກ OSS, ແລະພົບວ່າມັນສືບຕໍ່ຢູ່ໃນບຸກຄົນ. LumoSQL. ໃນເດືອນມັງກອນ 2020, ຜູ້ຂຽນຂອງໂຄງການນີ້ແມ່ນ Den Shearer ນໍາສະເຫນີ ມັນຢູ່ LinuxConfAu.

LMDB ສ່ວນໃຫຍ່ແມ່ນໃຊ້ເປັນເຄື່ອງຈັກສໍາລັບຖານຂໍ້ມູນຄໍາຮ້ອງສະຫມັກ. ຫ້ອງສະຫມຸດເປັນຫນີ້ຮູບລັກສະນະຂອງມັນກັບນັກພັດທະນາ OpenLDAP, ຜູ້ທີ່ບໍ່ພໍໃຈກັບ BerkeleyDB ເປັນພື້ນຖານສໍາລັບໂຄງການຂອງພວກເຂົາ. ເລີ່ມຕົ້ນຈາກຫ້ອງສະຫມຸດເລັກນ້ອຍ ຕົ້ນໄມ້, Howard Chu ສາມາດສ້າງທາງເລືອກທີ່ເປັນທີ່ນິຍົມທີ່ສຸດຂອງເວລາຂອງພວກເຮົາ. ລາວໄດ້ອຸທິດບົດລາຍງານທີ່ດີເລີດຂອງລາວຕໍ່ກັບເລື່ອງນີ້, ເຊັ່ນດຽວກັນກັບໂຄງສ້າງພາຍໃນຂອງ LMDB. "ຖານຂໍ້ມູນທີ່ມີແຜນທີ່ຫນ່ວຍຄວາມຈໍາ Lightning". ຕົວຢ່າງທີ່ດີຂອງການເອົາຊະນະສະຖານທີ່ເກັບຮັກສາໄດ້ຖືກແບ່ງປັນໂດຍ Leonid Yuryev (aka ເອີ) ຈາກ Positive Technologies ໃນບົດລາຍງານຂອງລາວຢູ່ທີ່ Highload 2015 "ເຄື່ອງຈັກ LMDB ເປັນແຊ້ມພິເສດ". ໃນນັ້ນ, ລາວເວົ້າກ່ຽວກັບ LMDB ໃນສະພາບການຂອງວຽກງານທີ່ຄ້າຍຄືກັນຂອງການປະຕິບັດ ReOpenLDAP, ແລະ LevelDB ໄດ້ຖືກວິພາກວິຈານປຽບທຽບແລ້ວ. ເປັນຜົນມາຈາກການຈັດຕັ້ງປະຕິບັດ, ເທັກໂນໂລຍີໃນທາງບວກກໍ່ມີທາງອອກທີ່ພັດທະນາຢ່າງຫ້າວຫັນ MDBX ທີ່ມີລັກສະນະລົດຊາດຫຼາຍ, ການປັບປຸງແລະ ແກ້ໄຂຂໍ້ຜິດພາດ.

LMDB ມັກຈະຖືກນໍາໃຊ້ເປັນບ່ອນເກັບຂໍ້ມູນ. ຕົວຢ່າງ, ຕົວທ່ອງເວັບ Mozilla Firefox ເລືອກ ມັນສໍາລັບຄວາມຕ້ອງການຈໍານວນຫນຶ່ງ, ແລະ, ເລີ່ມຕົ້ນຈາກຮຸ່ນ 9, Xcode ມັກ SQLite ຂອງມັນສໍາລັບການເກັບຮັກສາດັດສະນີ.

ເຄື່ອງຈັກຍັງໄດ້ສ້າງເຄື່ອງຫມາຍຂອງຕົນໃນໂລກຂອງການພັດທະນາມືຖື. ຮ່ອງຮອຍຂອງການນໍາໃຊ້ຂອງມັນສາມາດເປັນ ເພື່ອຊອກຫາ ໃນລູກຄ້າ iOS ສໍາລັບ Telegram. LinkedIn ໄດ້ໄປຕື່ມອີກແລະເລືອກ LMDB ເປັນການເກັບຮັກສາໄວ້ໃນຕອນຕົ້ນສໍາລັບກອບການເກັບຂໍ້ມູນ Rocket Data, ເຊິ່ງຢູ່ໃນບ້ານຂອງຕົນ. ບອກ ໃນບົດຄວາມຂອງລາວໃນປີ 2016.

LMDB ກໍາລັງປະສົບຄວາມສໍາເລັດໃນການຕໍ່ສູ້ເພື່ອສະຖານທີ່ຢູ່ໃນແດດໃນຊ່ອງຫວ່າງໂດຍ BerkeleyDB ຫຼັງຈາກທີ່ມັນຢູ່ພາຍໃຕ້ການຄວບຄຸມຂອງ Oracle. ຫ້ອງສະຫມຸດໄດ້ຖືກຮັກສໍາລັບຄວາມໄວແລະຄວາມຫນ້າເຊື່ອຖືຂອງມັນ, ເຖິງແມ່ນວ່າເມື່ອທຽບກັບເພື່ອນມິດຂອງຕົນ. ຕາມທີ່ທ່ານຮູ້, ບໍ່ມີອາຫານທ່ຽງຟຣີ, ແລະຂ້າພະເຈົ້າຢາກຈະເນັ້ນຫນັກເຖິງການຄ້າທີ່ເຈົ້າຈະຕ້ອງປະເຊີນໃນເວລາເລືອກລະຫວ່າງ LMDB ແລະ SQLite. ແຜນວາດຂ້າງເທິງນີ້ສະແດງໃຫ້ເຫັນຢ່າງຈະແຈ້ງວ່າຄວາມໄວທີ່ເພີ່ມຂຶ້ນແມ່ນບັນລຸໄດ້ຢ່າງໃດ. ທໍາອິດ, ພວກເຮົາບໍ່ໄດ້ຈ່າຍເງິນສໍາລັບຊັ້ນເພີ່ມເຕີມຂອງ abstraction ຢູ່ເທິງສຸດຂອງການເກັບຮັກສາແຜ່ນ. ມັນເປັນທີ່ຊັດເຈນວ່າສະຖາປັດຕະຍະກໍາທີ່ດີຍັງບໍ່ສາມາດເຮັດໄດ້ໂດຍບໍ່ມີພວກມັນ, ແລະພວກມັນຈະປາກົດຢູ່ໃນລະຫັດຄໍາຮ້ອງສະຫມັກຢ່າງຫຼີກລ່ຽງ, ແຕ່ພວກມັນຈະອ່ອນກວ່າຫຼາຍ. ພວກມັນຈະບໍ່ປະກອບດ້ວຍຄຸນສົມບັດທີ່ບໍ່ຕ້ອງການໂດຍແອັບພລິເຄຊັນສະເພາະ, ຕົວຢ່າງ, ການສະຫນັບສະຫນູນການສອບຖາມໃນພາສາ SQL. ອັນທີສອງ, ມັນເປັນໄປໄດ້ທີ່ຈະປະຕິບັດແຜນທີ່ຂອງການດໍາເນີນງານຂອງແອັບພລິເຄຊັນຕາມຄໍາຮ້ອງຂໍການເກັບຮັກສາແຜ່ນທີ່ດີທີ່ສຸດ. ຖ້າ SQLite ໃນວຽກຂອງຂ້ອຍ ແມ່ນອີງໃສ່ຄວາມຕ້ອງການສະຖິຕິສະເລ່ຍຂອງຄໍາຮ້ອງສະຫມັກສະເລ່ຍ, ຫຼັງຈາກນັ້ນທ່ານ, ເປັນຜູ້ພັດທະນາແອັບພລິເຄຊັນ, ຮູ້ດີກ່ຽວກັບສະຖານະການວຽກຕົ້ນຕໍ. ສໍາລັບການແກ້ໄຂທີ່ມີປະສິດຕິຜົນຫຼາຍ, ທ່ານຈະຕ້ອງຈ່າຍຄ່າລາຄາທີ່ເພີ່ມຂຶ້ນທັງສໍາລັບການພັດທະນາການແກ້ໄຂເບື້ອງຕົ້ນແລະການສະຫນັບສະຫນູນຕໍ່ມາ.

3. ສາມເສົາຄ້ຳຂອງ LMDB

ໂດຍໄດ້ເບິ່ງ LMDB ຈາກສາຍຕາຂອງນົກ, ມັນແມ່ນເວລາທີ່ຈະລົງເລິກ. ສາມພາກຕໍ່ໄປຈະຖືກອຸທິດໃຫ້ກັບການວິເຄາະຂອງເສົາຫຼັກຕົ້ນຕໍທີ່ສະຖາປັດຕະຍະກໍາເກັບຮັກສາໄວ້:

ໄຟລ໌ທີ່ມີແຜນທີ່ຫນ່ວຍຄວາມຈໍາເປັນກົນໄກສໍາລັບການເຮັດວຽກກັບແຜ່ນແລະ synchronizing ໂຄງສ້າງຂໍ້ມູນພາຍໃນ.
B+-tree ເປັນອົງການຈັດຕັ້ງຂອງໂຄງສ້າງຂອງຂໍ້ມູນທີ່ເກັບໄວ້.
Copy-on-write ເປັນວິທີການສະຫນອງຄຸນສົມບັດການເຮັດທຸລະກໍາ ACID ແລະ multiversion.

3.1. ປາວານ #1. ໄຟລ໌ທີ່ມີແຜນທີ່ດ້ວຍໜ່ວຍຄວາມຈຳ

ໄຟລ໌ທີ່ມີແຜນທີ່ຄວາມຊົງຈໍາແມ່ນອົງປະກອບສະຖາປັດຕະຍະກໍາທີ່ສໍາຄັນທີ່ພວກມັນຈະປາກົດຢູ່ໃນຊື່ຂອງ repository. ບັນຫາຂອງ caching ແລະ synchronization ການເຂົ້າເຖິງຂໍ້ມູນທີ່ເກັບໄວ້ແມ່ນປະໄວ້ທັງຫມົດໃນລະບົບປະຕິບັດການ. LMDB ບໍ່ມີແຄດພາຍໃນຕົວຂອງມັນເອງ. ນີ້ແມ່ນການຕັດສິນໃຈທີ່ມີສະຕິໂດຍຜູ້ຂຽນ, ນັບຕັ້ງແຕ່ການອ່ານຂໍ້ມູນໂດຍກົງຈາກໄຟລ໌ແຜນທີ່ຊ່ວຍໃຫ້ທ່ານສາມາດຕັດມຸມຫຼາຍໃນການປະຕິບັດເຄື່ອງຈັກ. ຂ້າງລຸ່ມນີ້ແມ່ນຢູ່ໄກຈາກບັນຊີລາຍຊື່ຄົບຖ້ວນຂອງບາງສ່ວນຂອງພວກເຂົາ.

ການຮັກສາຄວາມສອດຄ່ອງຂອງຂໍ້ມູນໃນການເກັບຮັກສາໃນເວລາທີ່ເຮັດວຽກກັບມັນຈາກຫຼາຍຂະບວນການກາຍເປັນຄວາມຮັບຜິດຊອບຂອງລະບົບປະຕິບັດການ. ໃນພາກຕໍ່ໄປ, ກົນໄກນີ້ໄດ້ຖືກປຶກສາຫາລືໃນລາຍລະອຽດແລະຮູບພາບ.
ການຂາດແຄສຈະລົບລ້າງ LMDB ອອກຈາກສ່ວນເກີນທີ່ກ່ຽວຂ້ອງກັບການຈັດສັນແບບເຄື່ອນໄຫວ. ການອ່ານຂໍ້ມູນໃນທາງປະຕິບັດຫມາຍເຖິງການກໍານົດຕົວຊີ້ໄປຫາທີ່ຢູ່ທີ່ຖືກຕ້ອງໃນຫນ່ວຍຄວາມຈໍາ virtual ແລະບໍ່ມີຫຍັງອີກ. ມັນຟັງຄືນິຍາຍວິທະຍາສາດ, ແຕ່ໃນລະຫັດແຫຼ່ງການເກັບຮັກສາທຸກການໂທໄປຫາ calloc ແມ່ນສຸມໃສ່ການທໍາງານຂອງການຕັ້ງຄ່າການເກັບຮັກສາ.
ການບໍ່ມີ cache ຍັງຫມາຍຄວາມວ່າບໍ່ມີ locks ທີ່ກ່ຽວຂ້ອງກັບ synchronization ຂອງການເຂົ້າເຖິງຂອງເຂົາເຈົ້າ. ຜູ້ອ່ານ, ເຊິ່ງສາມາດມີຈໍານວນຜູ້ອ່ານທີ່ຕົນເອງມັກໃນເວລາດຽວກັນ, ບໍ່ພົບ mutex ດຽວໃນວິທີການຂອງເຂົາເຈົ້າກັບຂໍ້ມູນ. ດ້ວຍເຫດນີ້, ຄວາມໄວໃນການອ່ານມີຄວາມສາມາດໃນການຂະຫຍາຍເສັ້ນທີ່ເຫມາະສົມໂດຍອີງໃສ່ຈໍານວນ CPU. ໃນ LMDB, ພຽງແຕ່ການດັດແກ້ການດໍາເນີນການແມ່ນ synchronized. ສາມາດມີນັກຂຽນໄດ້ເທື່ອລະຄົນເທົ່ານັ້ນ.
ຕໍາ່ສຸດທີ່ຂອງ caching ແລະ synchronization logic ລົບລ້າງປະເພດຂອງຄວາມສັບສົນທີ່ສຸດຂອງຄວາມຜິດພາດທີ່ກ່ຽວຂ້ອງກັບການເຮັດວຽກໃນສະພາບແວດລ້ອມຫຼາຍ threaded. ມີສອງການສຶກສາຖານຂໍ້ມູນທີ່ຫນ້າສົນໃຈໃນກອງປະຊຸມ Usenix OSDI 2014: "ລະບົບໄຟລ໌ທັງຫມົດບໍ່ໄດ້ຖືກສ້າງຂື້ນເທົ່າທຽມກັນ: ກ່ຽວກັບຄວາມສັບສົນຂອງການສ້າງຄໍາຮ້ອງສະຫມັກທີ່ສອດຄ່ອງກັນ" и "ການທໍລະມານຖານຂໍ້ມູນເພື່ອຄວາມມ່ວນແລະຜົນກໍາໄລ". ຈາກພວກມັນທ່ານສາມາດລວບລວມຂໍ້ມູນກ່ຽວກັບທັງຄວາມຫນ້າເຊື່ອຖືທີ່ບໍ່ເຄີຍມີມາກ່ອນຂອງ LMDB ແລະການປະຕິບັດເກືອບບໍ່ມີຂໍ້ບົກພ່ອງຂອງຄຸນສົມບັດການເຮັດທຸລະກໍາ ACID, ເຊິ່ງດີກວ່າຂອງ SQLite.
ຫນ້ອຍທີ່ສຸດຂອງ LMDB ອະນຸຍາດໃຫ້ເຄື່ອງເປັນຕົວແທນຂອງລະຫັດຂອງມັນຢູ່ໃນ cache L1 ຂອງໂປເຊດເຊີທີ່ມີລັກສະນະຄວາມໄວຕໍ່ໄປ.

ແຕ່ຫນ້າເສຍດາຍ, ໃນ iOS, ດ້ວຍໄຟລ໌ທີ່ມີແຜນທີ່ຫນ່ວຍຄວາມຈໍາ, ທຸກສິ່ງທຸກຢ່າງແມ່ນບໍ່ເປັນ cloudless ດັ່ງທີ່ພວກເຮົາຕ້ອງການ. ເພື່ອສົນທະນາກ່ຽວກັບຂໍ້ບົກຜ່ອງທີ່ກ່ຽວຂ້ອງກັບພວກເຂົາຢ່າງມີສະຕິຫຼາຍຂຶ້ນ, ມັນຈໍາເປັນຕ້ອງຈື່ຈໍາຫຼັກການທົ່ວໄປຂອງການປະຕິບັດກົນໄກນີ້ໃນລະບົບປະຕິບັດການ.

ຂໍ້ມູນທົ່ວໄປກ່ຽວກັບໄຟລ໌ທີ່ມີແຜນທີ່ຫນ່ວຍຄວາມຈໍາ

ດ້ວຍທຸກໆແອັບພລິເຄຊັນທີ່ເຮັດວຽກ, ລະບົບປະຕິບັດການໄດ້ເຊື່ອມໂຍງກັບຫນ່ວຍງານທີ່ເອີ້ນວ່າຂະບວນການ. ແຕ່ລະຂະບວນການໄດ້ຖືກຈັດສັນເປັນທີ່ຢູ່ຕິດຕໍ່ກັນ, ເຊິ່ງມັນວາງທຸກຢ່າງທີ່ມັນຕ້ອງການເພື່ອດໍາເນີນການ. ຢູ່ທີ່ທີ່ຢູ່ຕ່ໍາສຸດມີສ່ວນທີ່ມີລະຫັດແລະຂໍ້ມູນແລະຊັບພະຍາກອນທີ່ຍາກ. ຕໍ່ໄປແມ່ນການຂະຫຍາຍຕົວຂອງພື້ນທີ່ທີ່ຢູ່ແບບເຄື່ອນໄຫວ, ທີ່ຮູ້ຈັກກັນດີກັບພວກເຮົາພາຍໃຕ້ຊື່ heap. ມັນປະກອບດ້ວຍທີ່ຢູ່ຂອງຫນ່ວຍງານທີ່ປາກົດໃນລະຫວ່າງການດໍາເນີນງານຂອງໂຄງການ. ຢູ່ເທິງສຸດແມ່ນພື້ນທີ່ຄວາມຊົງຈໍາທີ່ໃຊ້ໂດຍ stack ຄໍາຮ້ອງສະຫມັກ. ມັນເຕີບໂຕຫຼືເຮັດສັນຍາ; ໃນຄໍາສັບຕ່າງໆອື່ນໆ, ຂະຫນາດຂອງມັນຍັງມີລັກສະນະເຄື່ອນໄຫວ. ເພື່ອປ້ອງກັນບໍ່ໃຫ້ stack ແລະ heap ຍູ້ແລະແຊກແຊງເຊິ່ງກັນແລະກັນ, ພວກມັນຕັ້ງຢູ່ປາຍທີ່ແຕກຕ່າງກັນຂອງພື້ນທີ່ທີ່ຢູ່. ມັນມີຂຸມລະຫວ່າງສອງສ່ວນແບບເຄື່ອນໄຫວຢູ່ດ້ານເທິງແລະລຸ່ມ. ລະບົບປະຕິບັດການໃຊ້ທີ່ຢູ່ໃນພາກກາງນີ້ເພື່ອເຊື່ອມໂຍງກັບຫຼາຍໆຫນ່ວຍງານກັບຂະບວນການ. ໂດຍສະເພາະ, ມັນສາມາດເຊື່ອມໂຍງຊຸດທີ່ຢູ່ຢ່າງຕໍ່ເນື່ອງທີ່ແນ່ນອນກັບໄຟລ໌ໃນແຜ່ນ. ໄຟລ໌ດັ່ງກ່າວເອີ້ນວ່າ memory-mapped.

ພື້ນທີ່ທີ່ຢູ່ຈັດສັນໃຫ້ຂະບວນການແມ່ນໃຫຍ່ຫຼວງ. ໃນທາງທິດສະດີ, ຈໍານວນທີ່ຢູ່ຖືກຈໍາກັດພຽງແຕ່ຂະຫນາດຂອງຕົວຊີ້, ເຊິ່ງຖືກກໍານົດໂດຍຄວາມອາດສາມາດບິດຂອງລະບົບ. ຖ້າຄວາມຊົງຈໍາທາງກາຍະພາບຖືກແຜນທີ່ກັບມັນ 1-to-1, ຫຼັງຈາກນັ້ນຂະບວນການທໍາອິດຈະກອດ RAM ທັງຫມົດ, ແລະຈະບໍ່ມີການເວົ້າກ່ຽວກັບ multitasking ໃດໆ.

ຢ່າງໃດກໍຕາມ, ຈາກປະສົບການຂອງພວກເຮົາພວກເຮົາຮູ້ວ່າລະບົບປະຕິບັດການທີ່ທັນສະໄຫມສາມາດປະຕິບັດຂະບວນການຫຼາຍເທົ່າທີ່ຕ້ອງການ. ນີ້ແມ່ນເປັນໄປໄດ້ຍ້ອນຄວາມຈິງທີ່ວ່າພວກເຂົາພຽງແຕ່ຈັດສັນຄວາມຊົງຈໍາຫຼາຍໃນການປຸງແຕ່ງໃນເຈ້ຍ, ແຕ່ໃນຄວາມເປັນຈິງແລ້ວພວກເຂົາໂຫລດເຂົ້າໄປໃນຫນ່ວຍຄວາມຈໍາທາງດ້ານຮ່າງກາຍຕົ້ນຕໍພຽງແຕ່ສ່ວນທີ່ມີຄວາມຕ້ອງການຢູ່ທີ່ນີ້ແລະໃນປັດຈຸບັນ. ດັ່ງນັ້ນ, ຫນ່ວຍຄວາມຈໍາທີ່ກ່ຽວຂ້ອງກັບຂະບວນການເອີ້ນວ່າ virtual.

ລະບົບປະຕິບັດການຈັດຕັ້ງຄວາມຊົງຈໍາ virtual ແລະທາງດ້ານຮ່າງກາຍເຂົ້າໄປໃນຫນ້າຂອງຂະຫນາດໃດຫນຶ່ງ. ທັນທີທີ່ຫນ້າທີ່ແນ່ນອນຂອງຫນ່ວຍຄວາມຈໍາ virtual ແມ່ນຢູ່ໃນຄວາມຕ້ອງການ, ລະບົບປະຕິບັດການຈະໂຫລດມັນເຂົ້າໄປໃນຫນ່ວຍຄວາມຈໍາທາງດ້ານຮ່າງກາຍແລະກົງກັບພວກເຂົາຢູ່ໃນຕາຕະລາງພິເສດ. ຖ້າບໍ່ມີສະລັອດຕິງຟຣີ, ຫຼັງຈາກນັ້ນຫນຶ່ງໃນຫນ້າທີ່ໂຫລດກ່ອນຫນ້ານີ້ຈະຖືກຄັດລອກໃສ່ແຜ່ນດິດ, ແລະຫນຶ່ງທີ່ຕ້ອງການຈະເອົາສະຖານທີ່ຂອງມັນ. ຂັ້ນຕອນນີ້, ທີ່ພວກເຮົາຈະກັບຄືນໄປໃນໄວໆນີ້, ເອີ້ນວ່າ swapping. ຮູບຂ້າງລຸ່ມນີ້ສະແດງໃຫ້ເຫັນຂະບວນການທີ່ໄດ້ອະທິບາຍ. ໃນມັນ, ຫນ້າ A ທີ່ມີທີ່ຢູ່ 0 ໄດ້ຖືກໂຫລດແລະວາງໄວ້ໃນຫນ້າຫນ່ວຍຄວາມຈໍາຕົ້ນຕໍທີ່ມີທີ່ຢູ່ 4. ຄວາມຈິງນີ້ໄດ້ຖືກສະທ້ອນໃຫ້ເຫັນໃນຕາຕະລາງການຕິດຕໍ່ຢູ່ໃນຫ້ອງເລກ 0.

ເລື່ອງແມ່ນຄືກັນແທ້ກັບໄຟລ໌ທີ່ມີແຜນທີ່ຢູ່ໃນຫນ່ວຍຄວາມຈໍາ. ຕາມເຫດຜົນ, ພວກມັນຖືກ supposedly ຢ່າງຕໍ່ເນື່ອງແລະຕັ້ງຢູ່ທັງຫມົດໃນພື້ນທີ່ທີ່ຢູ່ virtual. ຢ່າງໃດກໍຕາມ, ພວກເຂົາເຈົ້າເຂົ້າໄປໃນຫນ້າຄວາມຊົງຈໍາທາງດ້ານຮ່າງກາຍໂດຍຫນ້າແລະພຽງແຕ່ຕາມຄໍາຮ້ອງຂໍ. ການດັດແກ້ຂອງຫນ້າດັ່ງກ່າວແມ່ນ synchronized ກັບໄຟລ໌ໃນແຜ່ນ. ດ້ວຍວິທີນີ້, ທ່ານສາມາດປະຕິບັດ I / O ໄຟລ໌ໂດຍພຽງແຕ່ເຮັດວຽກກັບ bytes ໃນຫນ່ວຍຄວາມຈໍາ - ການປ່ຽນແປງທັງຫມົດຈະຖືກໂອນໂດຍອັດຕະໂນມັດໂດຍ kernel ລະບົບປະຕິບັດການໄປຫາໄຟລ໌ແຫຼ່ງ.
'' '"
ຮູບພາບຂ້າງລຸ່ມນີ້ສະແດງໃຫ້ເຫັນວິທີການ LMDB synchronizes ສະຖານະຂອງຕົນໃນເວລາທີ່ເຮັດວຽກກັບຖານຂໍ້ມູນຈາກຂະບວນການທີ່ແຕກຕ່າງກັນ. ໂດຍການສ້າງແຜນທີ່ຄວາມຊົງຈໍາ virtual ຂອງຂະບວນການທີ່ແຕກຕ່າງກັນກັບໄຟລ໌ດຽວກັນ, ພວກເຮົາ de facto oblige ລະບົບປະຕິບັດການເພື່ອ synchronize transitively ຕັນຂອງສະຖານທີ່ທີ່ຢູ່ຂອງເຂົາເຈົ້າກັບກັນແລະກັນ, ບ່ອນທີ່ LMDB ເບິ່ງ.
'' '"

nuance ທີ່ສໍາຄັນແມ່ນວ່າ LMDB, ໂດຍຄ່າເລີ່ມຕົ້ນ, ດັດແກ້ໄຟລ໌ຂໍ້ມູນໂດຍຜ່ານກົນໄກການໂທຫາລະບົບການຂຽນ, ແລະສະແດງໄຟລ໌ຕົວມັນເອງໃນຮູບແບບອ່ານເທົ່ານັ້ນ. ວິທີການນີ້ມີສອງຜົນສະທ້ອນທີ່ສໍາຄັນ.

ຜົນສະທ້ອນທໍາອິດແມ່ນທົ່ວໄປກັບທຸກລະບົບປະຕິບັດການ. ໂດຍເນື້ອແທ້ແລ້ວຂອງມັນແມ່ນເພື່ອເພີ່ມການປ້ອງກັນຄວາມເສຍຫາຍໂດຍບໍ່ໄດ້ຕັ້ງໃຈກັບຖານຂໍ້ມູນໂດຍລະຫັດທີ່ບໍ່ຖືກຕ້ອງ. ຕາມທີ່ທ່ານຮູ້, ຄໍາແນະນໍາທີ່ສາມາດປະຕິບັດໄດ້ຂອງຂະບວນການແມ່ນບໍ່ເສຍຄ່າເພື່ອເຂົ້າເຖິງຂໍ້ມູນຈາກທຸກບ່ອນໃນພື້ນທີ່ທີ່ຢູ່ຂອງມັນ. ໃນເວລາດຽວກັນ, ດັ່ງທີ່ພວກເຮົາພຽງແຕ່ຈື່, ການສະແດງໄຟລ໌ໃນຮູບແບບອ່ານ - ຂຽນຫມາຍຄວາມວ່າຄໍາແນະນໍາໃດໆກໍ່ສາມາດດັດແປງມັນໄດ້. ຖ້ານາງເຮັດມັນໂດຍຄວາມຜິດພາດ, ພະຍາຍາມ, ຕົວຢ່າງ, ເພື່ອຂຽນທັບອົງປະກອບ array ຢູ່ໃນດັດຊະນີທີ່ບໍ່ມີຢູ່, ຫຼັງຈາກນັ້ນນາງສາມາດປ່ຽນໄຟລ໌ທີ່ຕັ້ງຢູ່ໃນທີ່ຢູ່ນີ້ໂດຍບັງເອີນ, ເຊິ່ງຈະນໍາໄປສູ່ການສໍ້ລາດບັງຫຼວງຂອງຖານຂໍ້ມູນ. ຖ້າໄຟລ໌ຖືກສະແດງຢູ່ໃນໂຫມດອ່ານເທົ່ານັ້ນ, ຄວາມພະຍາຍາມທີ່ຈະປ່ຽນພື້ນທີ່ທີ່ຢູ່ທີ່ສອດຄ້ອງກັນຈະນໍາໄປສູ່ການປິດໂຄງການສຸກເສີນດ້ວຍສັນຍານ. SIGSEGV, ແລະໄຟລ໌ຈະຍັງຄົງ intact.

ຜົນສະທ້ອນທີສອງແມ່ນສະເພາະກັບ iOS ແລ້ວ. ທັງຜູ້ຂຽນຫຼືແຫຼ່ງອື່ນໆບໍ່ໄດ້ກ່າວເຖິງມັນຢ່າງຈະແຈ້ງ, ແຕ່ຖ້າບໍ່ມີມັນ LMDB ຈະບໍ່ເຫມາະສົມສໍາລັບການເຮັດວຽກໃນລະບົບປະຕິບັດການມືຖືນີ້. ພາກຕໍ່ໄປແມ່ນອຸທິດໃຫ້ພິຈາລະນາຂອງຕົນ.

ຂໍ້ມູນສະເພາະຂອງໄຟລ໌ທີ່ມີແຜນທີ່ຄວາມຈຳໃນ iOS

ມີບົດລາຍງານທີ່ມະຫັດສະຈັນຢູ່ WWDC ໃນປີ 2018 "iOS Memory Deep Dive". ມັນບອກພວກເຮົາວ່າໃນ iOS, ຫນ້າທັງຫມົດທີ່ຢູ່ໃນຫນ່ວຍຄວາມຈໍາທາງດ້ານຮ່າງກາຍແມ່ນຫນຶ່ງໃນ 3 ປະເພດ: ເປື້ອນ, ບີບອັດແລະສະອາດ.

ໜ່ວຍຄວາມຈຳທີ່ສະອາດແມ່ນຊຸດໜ້າທີ່ສາມາດຖອດອອກໄດ້ຢ່າງບໍ່ເຈັບປວດຈາກຄວາມຊົງຈຳທາງຮ່າງກາຍ. ຂໍ້ມູນທີ່ເຂົາເຈົ້າມີສາມາດໄດ້ຮັບການໂຫຼດໃຫມ່ໄດ້ຕາມຄວາມຕ້ອງການຈາກແຫຼ່ງຂໍ້ມູນຕົ້ນສະບັບຂອງຕົນ. ໄຟລ໌ທີ່ມີແຜນທີ່ຫນ່ວຍຄວາມຈໍາແບບອ່ານເທົ່ານັ້ນຕົກຢູ່ໃນຫມວດນີ້. iOS ບໍ່ຢ້ານທີ່ຈະຍົກເລີກການໂຫຼດໜ້າເວັບທີ່ເຮັດແຜນທີ່ໃສ່ໄຟລ໌ຈາກໜ່ວຍຄວາມຈຳໄດ້ທຸກເວລາ, ເພາະວ່າພວກມັນຖືກຮັບປະກັນວ່າຈະຖືກ synchronized ກັບໄຟລ໌ໃນແຜ່ນ.
'' '"
ຫນ້າທີ່ຖືກດັດແກ້ທັງຫມົດສິ້ນສຸດລົງຢູ່ໃນຄວາມຊົງຈໍາທີ່ເປື້ອນ, ບໍ່ວ່າພວກມັນຈະຕັ້ງຢູ່ບ່ອນໃດກໍ່ຕາມ. ໂດຍສະເພາະ, ໄຟລ໌ທີ່ມີແຜນທີ່ຫນ່ວຍຄວາມຈໍາທີ່ຖືກດັດແກ້ໂດຍການຂຽນໃສ່ຫນ່ວຍຄວາມຈໍາ virtual ທີ່ກ່ຽວຂ້ອງກັບພວກມັນຈະຖືກຈັດປະເພດດ້ວຍວິທີນີ້. ເປີດ LMDB ດ້ວຍທຸງ MDB_WRITEMAP, ຫຼັງຈາກການປ່ຽນແປງມັນ, ທ່ານສາມາດກວດສອບການນີ້ສ່ວນບຸກຄົນ ..

ທັນທີທີ່ແອັບພລິເຄຊັນເລີ່ມຮັບເອົາຄວາມຊົງຈໍາທາງກາຍະພາບຫຼາຍເກີນໄປ, iOS ຈະຖືກບີບອັດຫນ້າເປື້ອນ. ຫນ່ວຍຄວາມຈໍາທັງຫມົດຖືກຄອບຄອງໂດຍຫນ້າທີ່ເປື້ອນແລະຖືກບີບອັດປະກອບເປັນອັນທີ່ເອີ້ນວ່າຮອຍຂອງຫນ່ວຍຄວາມຈໍາຂອງແອັບພລິເຄຊັນ. ເມື່ອມັນຮອດເກນທີ່ແນ່ນອນ, daemon ລະບົບ killer OOM ມາຫຼັງຈາກຂະບວນການແລະບັງຄັບມັນ. ນີ້ແມ່ນລັກສະນະພິເສດຂອງ iOS ເມື່ອທຽບກັບລະບົບປະຕິບັດການ desktop. ໃນທາງກົງກັນຂ້າມ, ການຫຼຸດຜ່ອນຄວາມຊົງຈໍາໂດຍການສະຫຼັບໜ້າຈາກໜ່ວຍຄວາມຈຳທາງກາຍໄປໃສ່ແຜ່ນແມ່ນບໍ່ໄດ້ສະໜອງໃຫ້ໃນ iOS. ເຫດຜົນພຽງແຕ່ສາມາດຄາດເດົາໄດ້. ບາງທີຂັ້ນຕອນຂອງການຍ້າຍຫນ້າຢ່າງເຂັ້ມງວດໄປຫາແຜ່ນແລະກັບຄືນໄປບ່ອນແມ່ນໃຊ້ພະລັງງານເກີນໄປສໍາລັບອຸປະກອນມືຖື, ຫຼື iOS ຊ່ວຍປະຢັດຊັບພະຍາກອນຂອງຈຸລັງການຂຽນຄືນໃຫມ່ໃນ SSD drives, ຫຼືບາງທີຜູ້ອອກແບບບໍ່ພໍໃຈກັບການປະຕິບັດໂດຍລວມຂອງລະບົບ, ບ່ອນທີ່ທຸກສິ່ງທຸກຢ່າງແມ່ນ. ແລກປ່ຽນຢູ່ສະເຫມີ. ຍ້ອນວ່າມັນອາດຈະເປັນ, ຄວາມຈິງຍັງຄົງເປັນຄວາມຈິງ.

ຂ່າວດີ, ທີ່ໄດ້ກ່າວມາແລ້ວກ່ອນຫນ້ານີ້, ແມ່ນວ່າ LMDB ໂດຍຄ່າເລີ່ມຕົ້ນບໍ່ໄດ້ໃຊ້ກົນໄກ mmap ເພື່ອປັບປຸງໄຟລ໌. ນີ້ຫມາຍຄວາມວ່າຂໍ້ມູນທີ່ສະແດງໄດ້ຖືກຈັດປະເພດໂດຍ iOS ເປັນຫນ່ວຍຄວາມຈໍາທີ່ສະອາດແລະບໍ່ໄດ້ປະກອບສ່ວນເຂົ້າໃນຄວາມຈໍາ. ທ່ານສາມາດກວດສອບນີ້ໂດຍໃຊ້ເຄື່ອງມື Xcode ທີ່ເອີ້ນວ່າ VM Tracker. ຮູບໜ້າຈໍຂ້າງລຸ່ມນີ້ສະແດງສະຖານະຂອງໜ່ວຍຄວາມຈຳສະເໝືອນຂອງ iOS ຂອງແອັບພລິເຄຊັນ Cloud ໃນລະຫວ່າງການເຮັດວຽກ. ໃນຕອນເລີ່ມຕົ້ນ, 2 ຕົວຢ່າງ LMDB ໄດ້ຖືກເລີ່ມຕົ້ນຢູ່ໃນມັນ. ທໍາອິດໄດ້ຖືກອະນຸຍາດໃຫ້ສະແດງໄຟລ໌ຂອງລາວໃນ 1GiB ຂອງຫນ່ວຍຄວາມຈໍາ virtual, ທີສອງ - 512MiB. ເຖິງວ່າຈະມີຄວາມຈິງທີ່ວ່າການເກັບຮັກສາທັງສອງຄອບຄອງຈໍານວນທີ່ແນ່ນອນຂອງຄວາມຊົງຈໍາທີ່ຢູ່ອາໃສ, ທັງສອງຂອງພວກເຂົາບໍ່ປະກອບສ່ວນຂະຫນາດເປື້ອນ.

ແລະໃນປັດຈຸບັນມັນເຖິງເວລາສໍາລັບຂ່າວຮ້າຍ. ຂໍຂອບໃຈກັບກົນໄກ swap ໃນລະບົບປະຕິບັດການ desktop 64-bit, ແຕ່ລະຂະບວນການສາມາດຄອບຄອງພື້ນທີ່ທີ່ຢູ່ virtual ຫຼາຍເທົ່າທີ່ພື້ນທີ່ຮາດດິດຟຣີສໍາລັບການແລກປ່ຽນທີ່ມີທ່າແຮງຂອງມັນອະນຸຍາດໃຫ້. ການປ່ຽນແທນ swap ດ້ວຍການບີບອັດໃນ iOS ຫຼຸດລົງຢ່າງຫຼວງຫຼາຍທາງທິດສະດີ. ໃນປັດຈຸບັນຂະບວນການດໍາລົງຊີວິດທັງຫມົດຕ້ອງເຫມາະກັບຫນ່ວຍຄວາມຈໍາຕົ້ນຕໍ (ອ່ານ RAM), ແລະທັງຫມົດທີ່ບໍ່ເຫມາະຕ້ອງຖືກບັງຄັບໃຫ້ຢຸດເຊົາ. ນີ້ແມ່ນໄດ້ລະບຸໄວ້ໃນທີ່ໄດ້ກ່າວມາຂ້າງເທິງ ລາຍງານ, ແລະໃນ ເອກະສານທາງການ. ດ້ວຍເຫດນີ້, iOS ຈຳກັດຈຳນວນໜ່ວຍຄວາມຈຳທີ່ສາມາດໃຊ້ໄດ້ຢ່າງໜັກໜ່ວງສຳລັບການຈັດສັນຜ່ານ mmap. ທີ່ນີ້ ທີ່ນີ້ ທ່ານສາມາດເບິ່ງຂໍ້ຈໍາກັດຂອງຈໍານວນຂອງຫນ່ວຍຄວາມຈໍາທີ່ສາມາດໄດ້ຮັບການຈັດສັນໃນອຸປະກອນທີ່ແຕກຕ່າງກັນໂດຍນໍາໃຊ້ການໂທລະບົບນີ້. ໃນແບບສະມາດໂຟນທີ່ທັນສະໄຫມທີ່ສຸດ, iOS ໄດ້ກາຍເປັນຄວາມກວ້າງໃຫຍ່ໂດຍ 2 gigabytes, ແລະໃນຮຸ່ນເທິງຂອງ iPad - ໂດຍ 4. ໃນການປະຕິບັດ, ແນ່ນອນ, ທ່ານຕ້ອງໄດ້ສຸມໃສ່ຮູບແບບອຸປະກອນທີ່ສະຫນັບສະຫນູນຕ່ໍາສຸດ, ບ່ອນທີ່ທຸກສິ່ງທຸກຢ່າງແມ່ນ sad ຫຼາຍ. ຮ້າຍແຮງໄປກວ່ານັ້ນ, ໂດຍການເບິ່ງສະຖານະຫນ່ວຍຄວາມຈໍາຂອງແອັບພລິເຄຊັນໃນ VM Tracker, ທ່ານຈະພົບວ່າ LMDB ແມ່ນຢູ່ໄກຈາກອັນດຽວທີ່ອ້າງວ່າເປັນການສ້າງແຜນທີ່ຫນ່ວຍຄວາມຈໍາ. ຊິ້ນທີ່ດີຖືກກິນໄປໂດຍຜູ້ຈັດສັນລະບົບ, ໄຟລ໌ຊັບພະຍາກອນ, ກອບຮູບພາບ, ແລະຜູ້ລ້າທີ່ນ້ອຍກວ່າອື່ນໆ.

ອີງຕາມຜົນຂອງການທົດລອງໃນ Cloud, ພວກເຮົາມາຮອດຄ່າປະນີປະນອມຕໍ່ໄປນີ້ສໍາລັບຫນ່ວຍຄວາມຈໍາທີ່ຈັດສັນໂດຍ LMDB: 384 megabytes ສໍາລັບອຸປະກອນ 32-bit ແລະ 768 ສໍາລັບອຸປະກອນ 64-bit. ຫຼັງຈາກປະລິມານນີ້ຖືກໃຊ້ຫມົດແລ້ວ, ການປະຕິບັດການດັດແກ້ໃດໆກໍ່ເລີ່ມສິ້ນສຸດດ້ວຍລະຫັດ MDB_MAP_FULL. ພວກເຮົາສັງເກດເຫັນຄວາມຜິດພາດດັ່ງກ່າວໃນການຕິດຕາມຂອງພວກເຮົາ, ແຕ່ພວກມັນມີຂະຫນາດນ້ອຍພຽງພໍທີ່ຈະຢູ່ໃນຂັ້ນຕອນນີ້ພວກເຂົາສາມາດຖືກລະເລີຍ.

ເຫດຜົນທີ່ບໍ່ຊັດເຈນສໍາລັບການບໍລິໂພກຄວາມຈໍາຫຼາຍເກີນໄປໂດຍການເກັບຮັກສາສາມາດເປັນທຸລະກໍາທີ່ມີຊີວິດຊີວາ. ເພື່ອເຂົ້າໃຈວ່າສອງປະກົດການນີ້ເຊື່ອມຕໍ່ກັນແນວໃດ, ພວກເຮົາຈະໄດ້ຮັບການຊ່ວຍເຫຼືອໂດຍການພິຈາລະນາສອງເສົາຄ້ໍາທີ່ຍັງເຫຼືອຂອງ LMDB.

3.2. ປາວານ #2. B+-ຕົ້ນໄມ້

ເພື່ອຈຳລອງຕາຕະລາງຢູ່ເທິງບ່ອນເກັບຂໍ້ມູນທີ່ສຳຄັນ, ຄຳສັ່ງຕໍ່ໄປນີ້ຈະຕ້ອງມີຢູ່ໃນ API ຂອງມັນ:

ການໃສ່ອົງປະກອບໃຫມ່.
ຊອກຫາອົງປະກອບທີ່ມີລະຫັດທີ່ໃຫ້.
ການຖອນອົງປະກອບ.
Iterate ໃນໄລຍະຫ່າງຂອງກະແຈໃນລໍາດັບທີ່ເຂົາເຈົ້າໄດ້ຖືກຈັດຮຽງ.

ໂຄງສ້າງຂໍ້ມູນທີ່ງ່າຍດາຍທີ່ສຸດທີ່ສາມາດປະຕິບັດການທັງຫມົດສີ່ຢ່າງງ່າຍດາຍແມ່ນຕົ້ນໄມ້ຄົ້ນຫາສອງ. ແຕ່ລະຂໍ້ຂອງມັນເປັນຕົວແທນຂອງກະແຈທີ່ແບ່ງຊຸດຍ່ອຍທັງໝົດຂອງກະແຈລູກອອກເປັນສອງຕົ້ນຍ່ອຍ. ເບື້ອງຊ້າຍບັນຈຸສິ່ງທີ່ມີຂະໜາດນ້ອຍກວ່າພໍ່ແມ່, ແລະເບື້ອງຂວາບັນຈຸສິ່ງທີ່ໃຫຍ່ກວ່າ. ການໄດ້ຮັບຊຸດກະແຈທີ່ຖືກສັ່ງແມ່ນບັນລຸໄດ້ໂດຍຜ່ານການຫນຶ່ງຂອງການເດີນທາງຕົ້ນໄມ້ຄລາສສິກ

ຕົ້ນໄມ້ໄບນາຣີມີຂໍ້ບົກພ່ອງພື້ນຖານສອງຢ່າງທີ່ປ້ອງກັນບໍ່ໃຫ້ພວກມັນມີປະສິດທິພາບເປັນໂຄງສ້າງຂໍ້ມູນທີ່ອີງໃສ່ແຜ່ນ. ກ່ອນອື່ນ ໝົດ, ລະດັບຄວາມສົມດຸນຂອງພວກເຂົາແມ່ນບໍ່ສາມາດຄາດເດົາໄດ້. ມີຄວາມສ່ຽງຫຼາຍຂອງການໄດ້ຮັບຕົ້ນໄມ້ທີ່ຄວາມສູງຂອງສາຂາທີ່ແຕກຕ່າງກັນສາມາດແຕກຕ່າງກັນຢ່າງຫຼວງຫຼາຍ, ເຊິ່ງເຮັດໃຫ້ຄວາມສັບສົນຂອງການຄົ້ນຫາແບບ algorithmic ຮ້າຍແຮງຂຶ້ນເມື່ອທຽບກັບສິ່ງທີ່ຄາດຫວັງ. ອັນທີສອງ, ຄວາມອຸດົມສົມບູນຂອງການເຊື່ອມຕໍ່ຂ້າມລະຫວ່າງ nodes deprives binary tree ຂອງທ້ອງຖິ່ນໃນຫນ່ວຍຄວາມຈໍາ. nodes ປິດ (ໃນແງ່ຂອງການເຊື່ອມຕໍ່ລະຫວ່າງເຂົາເຈົ້າ) ສາມາດຕັ້ງຢູ່ໃນຫນ້າທີ່ແຕກຕ່າງກັນຫມົດໃນຫນ່ວຍຄວາມຈໍາ virtual. ດັ່ງນັ້ນ, ເຖິງແມ່ນວ່າການຂ້າມຜ່ານແບບງ່າຍໆຂອງຫຼາຍຈຸດໃກ້ຄຽງຢູ່ໃນຕົ້ນໄມ້ອາດຈະຮຽກຮ້ອງໃຫ້ມີການໄປຢ້ຽມຢາມຈໍານວນຫນ້າປຽບທຽບ. ນີ້ແມ່ນບັນຫາເຖິງແມ່ນວ່າໃນເວລາທີ່ພວກເຮົາສົນທະນາກ່ຽວກັບປະສິດທິພາບຂອງຕົ້ນໄມ້ຄູ່ເປັນໂຄງສ້າງຂໍ້ມູນໃນຫນ່ວຍຄວາມຈໍາ, ນັບຕັ້ງແຕ່ rotating ຫນ້າຢ່າງຕໍ່ເນື່ອງໃນ cache ຂອງໂປເຊດເຊີບໍ່ແມ່ນຄວາມສຸກລາຄາຖືກ. ເມື່ອມັນມາກັບການດຶງເອົາຫນ້າທີ່ກ່ຽວຂ້ອງກັບໂຫນດຈາກແຜ່ນເລື້ອຍໆ, ສະຖານະການຈະຫມົດໄປ ໜ້າເສົ້າໃຈທີ່ຢູ່

B-trees, ເປັນວິວັດທະນາຂອງຕົ້ນໄມ້ສອງ, ແກ້ໄຂບັນຫາທີ່ໄດ້ລະບຸໄວ້ໃນວັກທີ່ຜ່ານມາ. ປະການທໍາອິດ, ພວກເຂົາເຈົ້າແມ່ນການດຸ່ນດ່ຽງຕົນເອງ. ອັນທີສອງ, ແຕ່ລະຂໍ້ຂອງພວກມັນແຍກຊຸດຂອງລູກກະແຈບໍ່ອອກເປັນ 2, ແຕ່ເປັນຊຸດຍ່ອຍຍ່ອຍຂອງ M, ແລະຈໍານວນ M ສາມາດຂ້ອນຂ້າງໃຫຍ່, ຕາມລໍາດັບຂອງຫຼາຍຮ້ອຍ, ຫຼືຫຼາຍພັນຄົນ.

ດ້ວຍເຫດນີ້:

ແຕ່ລະ node ມີຈໍານວນຂະຫນາດໃຫຍ່ຂອງກະແຈທີ່ສັ່ງແລ້ວແລະຕົ້ນໄມ້ສັ້ນຫຼາຍ.
ຕົ້ນໄມ້ໄດ້ຮັບຊັບສິນຂອງທ້ອງຖິ່ນຂອງສະຖານທີ່ໃນຄວາມຊົງຈໍາ, ເນື່ອງຈາກວ່າກະແຈທີ່ມີມູນຄ່າໃກ້ຄຽງແມ່ນຕັ້ງຢູ່ຕາມທໍາມະຊາດຢູ່ຂ້າງກັນໃນຂໍ້ດຽວກັນຫຼືໃກ້ຄຽງ.
ຈໍານວນຂອງເສັ້ນທາງຜ່ານໃນເວລາທີ່ຫຼຸດລົງຕົ້ນໄມ້ໃນລະຫວ່າງການປະຕິບັດການຊອກຫາແມ່ນຫຼຸດລົງ.
ຈໍານວນຂອງຂໍ້ມູນເປົ້າຫມາຍທີ່ໄດ້ອ່ານໃນລະຫວ່າງການສອບຖາມໄລຍະແມ່ນຫຼຸດລົງ, ເນື່ອງຈາກວ່າພວກເຂົາແຕ່ລະມີຈໍານວນຫຼາຍຂອງກະແຈສັ່ງແລ້ວ.

LMDB ໃຊ້ການປ່ຽນແປງຂອງຕົ້ນໄມ້ B ທີ່ເອີ້ນວ່າຕົ້ນໄມ້ B+ ເພື່ອເກັບຮັກສາຂໍ້ມູນ. ແຜນວາດຂ້າງເທິງສະແດງໃຫ້ເຫັນສາມປະເພດຂອງ nodes ທີ່ມີຢູ່ໃນມັນ:

ຢູ່ເທິງສຸດແມ່ນຮາກ. ມັນ materializes ບໍ່ມີຫຍັງຫຼາຍກ່ວາແນວຄວາມຄິດຂອງຖານຂໍ້ມູນພາຍໃນສາງ. ພາຍໃນຫນຶ່ງຕົວຢ່າງ LMDB, ທ່ານສາມາດສ້າງຖານຂໍ້ມູນຈໍານວນຫນຶ່ງທີ່ແບ່ງປັນພື້ນທີ່ທີ່ຢູ່ virtual. ແຕ່ລະຄົນເລີ່ມຕົ້ນຈາກຮາກຂອງຕົນເອງ.
ໃນລະດັບຕໍ່າສຸດແມ່ນໃບ. ພວກເຂົາແລະພຽງແຕ່ພວກເຂົາມີຄູ່ທີ່ສໍາຄັນທີ່ເກັບໄວ້ໃນຖານຂໍ້ມູນ. ໂດຍວິທີທາງການ, ນີ້ແມ່ນລັກສະນະພິເສດຂອງຕົ້ນໄມ້ B +. ຖ້າ B-tree ປົກກະຕິເກັບຮັກສາສ່ວນມູນຄ່າໃນ nodes ຂອງທຸກລະດັບ, ຫຼັງຈາກນັ້ນການປ່ຽນແປງ B+ ແມ່ນມີພຽງແຕ່ຫນຶ່ງຕ່ໍາສຸດ. ມີການສ້ອມແຊມຄວາມເປັນຈິງນີ້, ພວກເຮົາຈະໂທຫາປະເພດຍ່ອຍຂອງຕົ້ນໄມ້ທີ່ໃຊ້ໃນ LMDB ພຽງແຕ່ເປັນ B-tree.
ລະຫວ່າງຮາກແລະໃບມີ 0 ຫຼືຫຼາຍກວ່າລະດັບດ້ານວິຊາການທີ່ມີເສັ້ນນໍາທາງ (ສາຂາ). ວຽກງານຂອງເຂົາເຈົ້າແມ່ນເພື່ອແບ່ງຊຸດຈັດລຽງຂອງຄີລະຫວ່າງໃບ.

ທາງກາຍຍະພາບ, ໂນດແມ່ນຕັນຂອງຄວາມຊົງຈຳຂອງຄວາມຍາວທີ່ກຳນົດໄວ້ລ່ວງໜ້າ. ຂະຫນາດຂອງພວກມັນແມ່ນຫຼາຍຂະຫນາດຂອງຫນ້າຫນ່ວຍຄວາມຈໍາໃນລະບົບປະຕິບັດການ, ທີ່ພວກເຮົາສົນທະນາຂ້າງເທິງ. ໂຄງສ້າງຂອງ node ແມ່ນສະແດງໃຫ້ເຫັນຂ້າງລຸ່ມນີ້. ສ່ວນຫົວມີຂໍ້ມູນ meta, ທີ່ຈະແຈ້ງທີ່ສຸດສໍາລັບຕົວຢ່າງແມ່ນ checksum. ຕໍ່ໄປແມ່ນຂໍ້ມູນກ່ຽວກັບການຊົດເຊີຍທີ່ຈຸລັງທີ່ມີຂໍ້ມູນຕັ້ງຢູ່. ຂໍ້ມູນສາມາດເປັນກະແຈໄດ້, ຖ້າພວກເຮົາເວົ້າກ່ຽວກັບ nodes navigation, ຫຼືຄູ່ຄີ-value ທັງຫມົດໃນກໍລະນີຂອງໃບ. ທ່ານສາມາດອ່ານເພີ່ມເຕີມກ່ຽວກັບໂຄງສ້າງຂອງຫນ້າໃນການເຮັດວຽກ. "ການປະເມີນຜົນຂອງຮ້ານທີ່ມີມູນຄ່າສູງປະສິດທິພາບ".

ໂດຍໄດ້ຈັດການກັບເນື້ອໃນພາຍໃນຂອງຫນ້າ, ພວກເຮົາຈະເປັນຕົວແທນຂອງ LMDB B-tree ໃນລັກສະນະທີ່ງ່າຍດາຍໃນຮູບແບບຕໍ່ໄປນີ້.

ຫນ້າທີ່ມີ nodes ຕັ້ງຢູ່ຕາມລໍາດັບຢູ່ໃນແຜ່ນ. ຫນ້າຕົວເລກທີ່ສູງກວ່າແມ່ນຕັ້ງຢູ່ໃນຕອນທ້າຍຂອງໄຟລ໌. ອັນທີ່ເອີ້ນວ່າຫນ້າ meta ມີຂໍ້ມູນກ່ຽວກັບການຊົດເຊີຍທີ່ຮາກຂອງຕົ້ນໄມ້ທັງຫມົດສາມາດພົບໄດ້. ເມື່ອເປີດໄຟລ໌, LMDB ສະແກນຫນ້າໄຟລ໌ແຕ່ລະຫນ້າຈາກທ້າຍໄປຫາຕົ້ນໃນການຊອກຫາຫນ້າ meta ທີ່ຖືກຕ້ອງແລະຜ່ານມັນຊອກຫາຖານຂໍ້ມູນທີ່ມີຢູ່.

ໃນປັດຈຸບັນ, ມີຄວາມຄິດກ່ຽວກັບໂຄງສ້າງທາງດ້ານເຫດຜົນແລະທາງດ້ານຮ່າງກາຍຂອງອົງການຈັດຕັ້ງຂໍ້ມູນ, ພວກເຮົາສາມາດກ້າວໄປຂ້າງຫນ້າເພື່ອພິຈາລະນາເສົາຫຼັກທີສາມຂອງ LMDB. ມັນແມ່ນການຊ່ວຍເຫຼືອຂອງມັນວ່າການດັດແປງການເກັບຮັກສາທັງຫມົດເກີດຂື້ນໃນການເຮັດທຸລະກໍາແລະການໂດດດ່ຽວຈາກກັນແລະກັນ, ໃຫ້ຖານຂໍ້ມູນເປັນຊັບສິນທັງຫມົດຂອງ multiversion.

3.3. ປາວານ #3. ສຳເນົາ-ຂຽນ

ບາງການດໍາເນີນງານ B-tree ກ່ຽວຂ້ອງກັບການປ່ຽນແປງຊຸດຂອງ nodes ຂອງມັນ. ຕົວຢ່າງຫນຶ່ງແມ່ນການເພີ່ມລະຫັດໃຫມ່ໃຫ້ກັບ node ທີ່ບັນລຸຄວາມສາມາດສູງສຸດຂອງມັນແລ້ວ. ໃນກໍລະນີນີ້, ມັນເປັນສິ່ງຈໍາເປັນ, ທໍາອິດ, ແຍກ node ເປັນສອງ, ແລະອັນທີສອງ, ເພື່ອເພີ່ມການເຊື່ອມຕໍ່ກັບ node budding ເດັກໃຫມ່ໃນພໍ່ແມ່ຂອງຕົນ. ຂັ້ນຕອນນີ້ອາດຈະເປັນອັນຕະລາຍຫຼາຍ. ຖ້າສໍາລັບເຫດຜົນບາງຢ່າງ (ອຸປະຕິເຫດ, ໄຟໄຫມ້, ແລະອື່ນໆ) ພຽງແຕ່ສ່ວນຫນຶ່ງຂອງການປ່ຽນແປງຈາກຊຸດດັ່ງກ່າວເກີດຂຶ້ນ, ຫຼັງຈາກນັ້ນຕົ້ນໄມ້ຈະຍັງຄົງຢູ່ໃນສະພາບທີ່ບໍ່ສອດຄ່ອງ.

ການແກ້ໄຂແບບດັ້ງເດີມອັນໜຶ່ງສໍາລັບການເຮັດໃຫ້ຖານຂໍ້ມູນມີຄວາມຜິດ-ທົນທານຕໍ່ແມ່ນການເພີ່ມໂຄງສ້າງຂໍ້ມູນໃນແຜ່ນເພີ່ມເຕີມຕໍ່ກັບ B-tree - ບັນທຶກການເຮັດທຸລະກໍາ, ເຊິ່ງເອີ້ນກັນວ່າບັນທຶກການຂຽນລ່ວງໜ້າ (WAL). ມັນເປັນໄຟລ໌ໃນຕອນທ້າຍຂອງການດໍາເນີນການທີ່ມີຈຸດປະສົງໄດ້ຖືກຂຽນຢ່າງເຂັ້ມງວດກ່ອນທີ່ຈະດັດແປງ B-tree ຕົວຂອງມັນເອງ. ດັ່ງນັ້ນ, ຖ້າຂໍ້ມູນຖືກກວດພົບໃນລະຫວ່າງການວິນິດໄສຕົນເອງ, ຖານຂໍ້ມູນຈະປຶກສາຫາລືກ່ຽວກັບບັນທຶກເພື່ອຈັດວາງຕົວເອງ.

LMDB ໄດ້ເລືອກວິທີການທີ່ແຕກຕ່າງກັນເປັນກົນໄກການທົນທານຕໍ່ຄວາມຜິດ, ເອີ້ນວ່າການຄັດລອກເທິງຂຽນ. ໂດຍເນື້ອແທ້ແລ້ວຂອງມັນແມ່ນວ່າແທນທີ່ຈະປັບປຸງຂໍ້ມູນໃນຫນ້າທີ່ມີຢູ່ແລ້ວ, ມັນທໍາອິດຄັດລອກມັນທັງຫມົດແລະເຮັດໃຫ້ການດັດແກ້ທັງຫມົດໃນສໍາເນົາ.

ຕໍ່ໄປ, ເພື່ອໃຫ້ຂໍ້ມູນທີ່ຖືກປັບປຸງໃຫ້ສາມາດໃຊ້ໄດ້, ມັນຈໍາເປັນຕ້ອງປ່ຽນການເຊື່ອມຕໍ່ກັບໂຫນດທີ່ໄດ້ກາຍເປັນປະຈຸບັນໃນໂຫນດແມ່ຂອງມັນ. ເນື່ອງຈາກວ່າມັນຍັງຕ້ອງໄດ້ຮັບການດັດແກ້ສໍາລັບການນີ້, ມັນຍັງຖືກຄັດລອກກ່ອນ. ຂະບວນການສືບຕໍ່ recursively ທັງຫມົດວິທີການຮາກ. ສິ່ງສຸດທ້າຍທີ່ຈະປ່ຽນແປງແມ່ນຂໍ້ມູນໃນຫນ້າ meta.

ຖ້າຂະບວນການຂັດຂ້ອງຢ່າງກະທັນຫັນໃນລະຫວ່າງຂັ້ນຕອນການປັບປຸງ, ຫຼັງຈາກນັ້ນຫນ້າ meta ໃຫມ່ຈະບໍ່ຖືກສ້າງ, ຫຼືມັນຈະບໍ່ຖືກຂຽນລົງໃນແຜ່ນທັງຫມົດ, ແລະ checksum ຂອງມັນຈະບໍ່ຖືກຕ້ອງ. ໃນທັງສອງກໍລະນີນີ້, ຫນ້າໃຫມ່ຈະບໍ່ສາມາດເຂົ້າເຖິງໄດ້, ແຕ່ຫນ້າເກົ່າຈະບໍ່ໄດ້ຮັບຜົນກະທົບ. ນີ້ລົບລ້າງຄວາມຕ້ອງການສໍາລັບ LMDB ໃນການຂຽນບັນທຶກລ່ວງຫນ້າເພື່ອຮັກສາຄວາມສອດຄ່ອງຂອງຂໍ້ມູນ. ໃນຄວາມເປັນຈິງ, ໂຄງສ້າງຂອງການເກັບຮັກສາຂໍ້ມູນໃນແຜ່ນທີ່ອະທິບາຍຂ້າງເທິງນີ້ໃນເວລາດຽວກັນໃຊ້ເວລາໃນຫນ້າທີ່ຂອງມັນ. ການຂາດບັນທຶກການເຮັດທຸລະກໍາທີ່ຊັດເຈນແມ່ນຫນຶ່ງໃນລັກສະນະຕ່າງໆຂອງ LMDB ທີ່ສະຫນອງຄວາມໄວໃນການອ່ານຂໍ້ມູນສູງ.

ການອອກແບບທີ່ໄດ້ຮັບຜົນ, ເອີ້ນວ່າ append-only B-tree, ຕາມທໍາມະຊາດສະຫນອງການໂດດດ່ຽວການເຮັດທຸລະກໍາແລະຫຼາຍຮຸ່ນ. ໃນ LMDB, ແຕ່ລະທຸລະກໍາທີ່ເປີດແມ່ນກ່ຽວຂ້ອງກັບຮາກຕົ້ນໄມ້ທີ່ກ່ຽວຂ້ອງໃນປະຈຸບັນ. ຈົນກ່ວາການເຮັດທຸລະກໍາສໍາເລັດ, ຫນ້າຂອງຕົ້ນໄມ້ທີ່ກ່ຽວຂ້ອງກັບມັນຈະບໍ່ຖືກປ່ຽນແປງຫຼືໃຊ້ໃຫມ່ສໍາລັບຂໍ້ມູນຮຸ່ນໃຫມ່. ດັ່ງນັ້ນ, ທ່ານສາມາດເຮັດວຽກໄດ້ດົນເທົ່າທີ່ທ່ານຕ້ອງການກັບຊຸດຂໍ້ມູນທີ່ກ່ຽວຂ້ອງໃນເວລານັ້ນ. ການເຮັດທຸລະກໍາໄດ້ຖືກເປີດ, ເຖິງແມ່ນວ່າການເກັບຮັກສາຈະສືບຕໍ່ປັບປຸງຢ່າງຫ້າວຫັນໃນເວລານີ້. ນີ້ແມ່ນຈຸດສໍາຄັນຂອງ multiversion, ເຮັດໃຫ້ LMDB ເປັນແຫຼ່ງຂໍ້ມູນທີ່ເຫມາະສົມສໍາລັບຄົນຮັກຂອງພວກເຮົາ UICollectionView. ມີການເປີດການເຮັດທຸລະກໍາ, ບໍ່ຈໍາເປັນຕ້ອງເພີ່ມຄວາມຊົງຈໍາຂອງແອັບພລິເຄຊັນໂດຍການສູບເອົາຂໍ້ມູນໃນປະຈຸບັນເຂົ້າໄປໃນໂຄງສ້າງໃນຫນ່ວຍຄວາມຈໍາບາງຢ່າງ, ເພາະວ່າຢ້ານວ່າບໍ່ມີຫຍັງເລີຍ. ຄຸນນະສົມບັດນີ້ຈໍາແນກ LMDB ຈາກ SQLite ດຽວກັນ, ເຊິ່ງບໍ່ສາມາດເວົ້າໂອ້ອວດຂອງການໂດດດ່ຽວທັງຫມົດດັ່ງກ່າວ. ໂດຍໄດ້ເປີດສອງທຸລະກໍາໃນຄັ້ງສຸດທ້າຍແລະລຶບບັນທຶກທີ່ແນ່ນອນພາຍໃນຫນຶ່ງຂອງພວກເຂົາ, ມັນຈະບໍ່ສາມາດໄດ້ຮັບບັນທຶກດຽວກັນພາຍໃນອັນທີສອງທີ່ຍັງເຫຼືອ.

ດ້ານ flip ຂອງຫຼຽນແມ່ນການບໍລິໂພກຄວາມຊົງຈໍາ virtual ທີ່ສູງຂຶ້ນຢ່າງຫຼວງຫຼາຍ. ສະໄລ້ສະແດງໃຫ້ເຫັນໂຄງສ້າງຖານຂໍ້ມູນຈະມີລັກສະນະແນວໃດຖ້າມັນຖືກແກ້ໄຂພ້ອມໆກັນກັບ 3 ການເຮັດທຸລະກໍາທີ່ເປີດອ່ານເບິ່ງຢູ່ໃນຮຸ່ນທີ່ແຕກຕ່າງກັນຂອງຖານຂໍ້ມູນ. ເນື່ອງຈາກ LMDB ບໍ່ສາມາດໃຊ້ຄືນໃຫມ່ຂໍ້ທີ່ສາມາດບັນລຸໄດ້ຈາກຮາກທີ່ກ່ຽວຂ້ອງກັບການເຮັດທຸລະກໍາໃນປະຈຸບັນ, ຮ້ານບໍ່ມີທາງເລືອກອື່ນນອກເຫນືອຈາກການຈັດສັນຮາກທີ່ສີ່ໃນຫນ່ວຍຄວາມຈໍາແລະອີກເທື່ອຫນຶ່ງ clone ຫນ້າທີ່ດັດແກ້ພາຍໃຕ້ມັນ.

ໃນທີ່ນີ້ມັນຈະເປັນປະໂຫຍດທີ່ຈະຈື່ຈໍາພາກສ່ວນກ່ຽວກັບໄຟລ໌ທີ່ມີແຜນທີ່ຫນ່ວຍຄວາມຈໍາ. ມັນເບິ່ງຄືວ່າການບໍລິໂພກເພີ່ມເຕີມຂອງຫນ່ວຍຄວາມຈໍາ virtual ບໍ່ຄວນເຮັດໃຫ້ພວກເຮົາກັງວົນຫຼາຍ, ເນື່ອງຈາກວ່າມັນບໍ່ໄດ້ປະກອບສ່ວນເຂົ້າໃນຄວາມຊົງຈໍາຂອງຄໍາຮ້ອງສະຫມັກ. ຢ່າງໃດກໍຕາມ, ໃນເວລາດຽວກັນ, ມັນໄດ້ຖືກສັງເກດເຫັນວ່າ iOS ມີຄວາມເຄັ່ງຄັດຫຼາຍໃນການຈັດສັນມັນ, ແລະພວກເຮົາບໍ່ສາມາດ, ເຊັ່ນໃນເຄື່ອງແມ່ຂ່າຍຫຼື desktop, ສະຫນອງພາກພື້ນ LMDB ຂອງ 1 terabyte ແລະບໍ່ຄິດກ່ຽວກັບຄຸນນະສົມບັດນີ້ເລີຍ. ຖ້າເປັນໄປໄດ້, ທ່ານຄວນພະຍາຍາມເຮັດໃຫ້ອາຍຸຂອງການເຮັດທຸລະກໍາສັ້ນທີ່ສຸດເທົ່າທີ່ເປັນໄປໄດ້.

4. ການອອກແບບໂຄງຮ່າງຂໍ້ມູນຢູ່ເທິງສຸດຂອງ key-value API

ໃຫ້ເລີ່ມຕົ້ນການວິເຄາະ API ຂອງພວກເຮົາໂດຍເບິ່ງສິ່ງທີ່ບໍ່ມີຕົວຕົນພື້ນຖານທີ່ສະຫນອງໃຫ້ໂດຍ LMDB: ສະພາບແວດລ້ອມແລະຖານຂໍ້ມູນ, ລະຫັດແລະມູນຄ່າ, ການເຮັດທຸລະກໍາແລະຕົວກະພິບ.

ບັນທຶກກ່ຽວກັບລາຍຊື່ລະຫັດ

ຫນ້າທີ່ທັງຫມົດໃນ LMDB API ສາທາລະນະສົ່ງຄືນຜົນຂອງການເຮັດວຽກຂອງພວກເຂົາໃນຮູບແບບຂອງລະຫັດຄວາມຜິດພາດ, ແຕ່ໃນທຸກລາຍການຕໍ່ໄປການກວດສອບຂອງມັນຖືກຍົກເວັ້ນສໍາລັບຄວາມຫຍໍ້ທໍ້. ສ້ອມ C++ wrappers lmdbxx, ໃນນັ້ນຄວາມຜິດພາດແມ່ນເປັນການຍົກເວັ້ນ C ++.

ໃນຖານະເປັນວິທີທີ່ໄວທີ່ສຸດໃນການເຊື່ອມຕໍ່ LMDB ກັບໂຄງການສໍາລັບ iOS ຫຼື macOS, ຂ້າພະເຈົ້າແນະນໍາ CocoaPod ຂອງຂ້ອຍ POSLMDB.

4.1. ບົດຄັດຫຍໍ້ພື້ນຖານ

ສະພາບແວດລ້ອມ

ໂຄງປະກອບການ MDB_env ແມ່ນບ່ອນເກັບມ້ຽນຂອງລັດພາຍໃນຂອງ LMDB. ຄອບຄົວຟັງຊັນນຳໜ້າ mdb_env ອະນຸຍາດໃຫ້ທ່ານສາມາດ configure ບາງຄຸນສົມບັດຂອງມັນ. ໃນກໍລະນີງ່າຍດາຍທີ່ສຸດ, ການເລີ່ມຕົ້ນຂອງເຄື່ອງຈັກເບິ່ງຄືວ່ານີ້.

mdb_env_create(env);
mdb_env_set_map_size(*env, 1024 * 1024 * 512)
mdb_env_open(*env, path.UTF8String, MDB_NOTLS, 0664);

ໃນຄໍາຮ້ອງສະຫມັກ Mail.ru Cloud, ພວກເຮົາໄດ້ປ່ຽນຄ່າເລີ່ມຕົ້ນພຽງແຕ່ສອງພາລາມິເຕີເທົ່ານັ້ນ.

ອັນທໍາອິດແມ່ນຂະຫນາດຂອງພື້ນທີ່ທີ່ຢູ່ virtual ທີ່ໄຟລ໌ເກັບຮັກສາຖືກແຜນທີ່. ແຕ່ຫນ້າເສຍດາຍ, ເຖິງແມ່ນວ່າຢູ່ໃນອຸປະກອນດຽວກັນ, ມູນຄ່າສະເພາະສາມາດແຕກຕ່າງກັນຢ່າງຫຼວງຫຼາຍຈາກການແລ່ນໄປຫາການແລ່ນ. ເພື່ອພິຈາລະນາຄຸນສົມບັດນີ້ຂອງ iOS, ປະລິມານການເກັບຮັກສາສູງສຸດແມ່ນເລືອກແບບໄດນາມິກ. ເລີ່ມຕົ້ນຈາກຄ່າທີ່ແນ່ນອນ, ມັນຖືກຫຼຸດລົງຕາມລໍາດັບຈົນກ່ວາຟັງຊັນ mdb_env_open ຈະບໍ່ສົ່ງຜົນໄດ້ຮັບທີ່ແຕກຕ່າງຈາກ ENOMEM. ໃນທາງທິດສະດີ, ຍັງມີວິທີກົງກັນຂ້າມ - ທໍາອິດຈັດສັນຫນ່ວຍຄວາມຈໍາຕໍາ່ສຸດທີ່ເຄື່ອງຈັກ, ແລະຫຼັງຈາກນັ້ນ, ເມື່ອໄດ້ຮັບຂໍ້ຜິດພາດ, MDB_MAP_FULL, ເພີ່ມຂຶ້ນ. ຢ່າງໃດກໍຕາມ, ມັນເປັນ thorny ຫຼາຍ. ເຫດຜົນແມ່ນວ່າຂັ້ນຕອນການຈັດສັນຫນ່ວຍຄວາມຈໍາຄືນໃຫມ່ (remap) ໂດຍໃຊ້ຟັງຊັນ mdb_env_set_map_size invalidates entities ທັງຫມົດ (ຕົວກະພິບ, ທຸລະກໍາ, ຄີແລະຄ່າ) ທີ່ໄດ້ຮັບໃນເມື່ອກ່ອນຈາກເຄື່ອງຈັກ. ການເອົາເຫດການນີ້ເຂົ້າໄປໃນບັນຊີຂອງລະຫັດຈະນໍາໄປສູ່ຄວາມສັບສົນທີ່ສໍາຄັນຂອງມັນ. ຢ່າງໃດກໍຕາມ, ຖ້າຄວາມຊົງຈໍາ virtual ມີຄວາມສໍາຄັນຫຼາຍສໍາລັບທ່ານ, ນີ້ອາດຈະເປັນເຫດຜົນທີ່ຈະພິຈາລະນາຢ່າງໃກ້ຊິດກ່ຽວກັບຄວາມຍາວຂອງສ້ອມທີ່ໄປໄກກ່ອນຫນ້າ. MDBX, ໃນບັນດາລັກສະນະທີ່ໄດ້ປະກາດມີ "ການປັບຂະຫນາດຖານຂໍ້ມູນອັດຕະໂນມັດໃນການບິນ".

ຕົວກໍານົດການທີສອງ, ມູນຄ່າເລີ່ມຕົ້ນທີ່ບໍ່ເຫມາະສົມກັບພວກເຮົາ, ຄວບຄຸມກົນໄກການຮັບປະກັນຄວາມປອດໄພຂອງກະທູ້. ຂໍອະໄພ, ຢ່າງໜ້ອຍ iOS 10 ມີບັນຫາກັບການຮອງຮັບການຈັດເກັບຂໍ້ມູນທ້ອງຖິ່ນ. ສໍາລັບເຫດຜົນນີ້, ໃນຕົວຢ່າງຂ້າງເທິງ, repository ໄດ້ຖືກເປີດດ້ວຍທຸງ MDB_NOTLS. ນອກເຫນືອໄປຈາກນີ້, ມັນຍັງມີຄວາມຈໍາເປັນ ສ້ອມ C++ wrapper lmdbxxເພື່ອຕັດຕົວແປທີ່ມີຄຸນລັກສະນະນີ້ແລະໃນມັນ.

ຖານຂໍ້ມູນ

ຖານຂໍ້ມູນແມ່ນຕົວຢ່າງ B-tree ແຍກຕ່າງຫາກ, ເຊິ່ງພວກເຮົາໄດ້ສົນທະນາຂ້າງເທິງ. ການເປີດຂອງມັນເກີດຂຶ້ນພາຍໃນທຸລະກໍາ, ເຊິ່ງອາດຈະເບິ່ງຄືວ່າແປກເລັກນ້ອຍໃນຕອນທໍາອິດ.

MDB_txn *txn;
MDB_dbi dbi;
mdb_txn_begin(env, NULL, MDB_RDONLY, &txn);
mdb_dbi_open(txn, NULL, MDB_CREATE, &dbi);
mdb_txn_abort(txn);

ແທ້ຈິງແລ້ວ, ການເຮັດທຸລະກໍາໃນ LMDB ແມ່ນຫນ່ວຍງານເກັບຮັກສາ, ບໍ່ແມ່ນຖານຂໍ້ມູນສະເພາະ. ແນວຄວາມຄິດນີ້ຊ່ວຍໃຫ້ທ່ານສາມາດປະຕິບັດການປະລໍາມະນູຢູ່ໃນຫນ່ວຍງານທີ່ຕັ້ງຢູ່ໃນຖານຂໍ້ມູນທີ່ແຕກຕ່າງກັນ. ໃນທາງທິດສະດີ, ນີ້ເປີດຄວາມເປັນໄປໄດ້ຂອງການສ້າງແບບຈໍາລອງຕາຕະລາງໃນຮູບແບບຂອງຖານຂໍ້ມູນທີ່ແຕກຕ່າງກັນ, ແຕ່ໃນເວລາຫນຶ່ງຂ້າພະເຈົ້າໄດ້ເອົາເສັ້ນທາງທີ່ແຕກຕ່າງກັນ, ອະທິບາຍລາຍລະອຽດຂ້າງລຸ່ມນີ້.

ຄີ ແລະຄ່າ

ໂຄງປະກອບການ MDB_val ແບບຈໍາລອງແນວຄວາມຄິດຂອງທັງສອງທີ່ສໍາຄັນແລະມູນຄ່າ. repository ບໍ່ມີຄວາມຄິດກ່ຽວກັບ semantics ຂອງເຂົາເຈົ້າ. ສໍາລັບນາງ, ບາງສິ່ງບາງຢ່າງອື່ນແມ່ນພຽງແຕ່ array ຂອງ bytes ຂອງຂະຫນາດທີ່ກໍານົດໄວ້. ຂະໜາດກະແຈສູງສຸດແມ່ນ 512 bytes.

typedef struct MDB_val {
    size_t mv_size;
    void *mv_data;
} MDB_val;

ການນໍາໃຊ້ເຄື່ອງປຽບທຽບ, ຮ້ານຈັດລຽງລໍາດັບກະແຈໃນລໍາດັບຕັ້ງຂຶ້ນ. ຖ້າຫາກວ່າທ່ານບໍ່ໄດ້ທົດແທນດ້ວຍຕົວທ່ານເອງ, ຫຼັງຈາກນັ້ນຄ່າເລີ່ມຕົ້ນທີ່ຈະຖືກນໍາໃຊ້, ເຊິ່ງຈັດລຽງລໍາດັບ byte-by-byte ໃນຄໍາສັ່ງ lexicographic.

ການເຮັດທຸລະ ກຳ

ໂຄງປະກອບການທຸລະກໍາແມ່ນອະທິບາຍໃນລະອຽດໃນ ບົດທີ່ຜ່ານມາ, ສະນັ້ນໃນທີ່ນີ້ຂ້າພະເຈົ້າຈະເວົ້າຄືນຄຸນສົມບັດຕົ້ນຕໍຂອງພວກເຂົາໂດຍຫຍໍ້:

ສະຫນັບສະຫນູນຄຸນສົມບັດພື້ນຖານທັງຫມົດ ເອຊີດີ: ປະລໍາມະນູ, ຄວາມສອດຄ່ອງ, ການໂດດດ່ຽວແລະຄວາມຫນ້າເຊື່ອຖື. ຂ້ອຍບໍ່ສາມາດຊ່ວຍໄດ້ແຕ່ສັງເກດວ່າມີຂໍ້ບົກພ່ອງກ່ຽວກັບຄວາມທົນທານໃນ macOS ແລະ iOS ທີ່ຖືກແກ້ໄຂໃນ MDBX. ທ່ານສາມາດອ່ານເພີ່ມເຕີມໃນຂອງພວກເຂົາ README.
ວິທີການເພື່ອ multithreading ແມ່ນອະທິບາຍໂດຍໂຄງການ "ນັກຂຽນດຽວ / ຜູ້ອ່ານຫຼາຍ". ນັກຂຽນບລັອກກັນແລະກັນ, ແຕ່ຢ່າບລັອກຜູ້ອ່ານ. ຜູ້ອ່ານບໍ່ໄດ້ຂັດຂວາງນັກຂຽນຫຼືກັນແລະກັນ.
ສະຫນັບສະຫນູນການເຮັດທຸລະກໍາທີ່ຊ້ອນກັນ.
Multiversion ສະຫນັບສະຫນູນ.

Multiversion ໃນ LMDB ແມ່ນດີຫຼາຍທີ່ຂ້ອຍຕ້ອງການສະແດງໃຫ້ເຫັນໃນການປະຕິບັດ. ຈາກລະຫັດຂ້າງລຸ່ມນີ້ທ່ານສາມາດເຫັນໄດ້ວ່າແຕ່ລະທຸລະກໍາເຮັດວຽກກັບແບບຂອງຖານຂໍ້ມູນທີ່ແທ້ຈິງໃນເວລາທີ່ເປີດ, ຖືກແຍກອອກຈາກການປ່ຽນແປງຕໍ່ໄປທັງຫມົດ. ການເລີ່ມຕົ້ນການເກັບຮັກສາແລະການເພີ່ມບັນທຶກການທົດສອບກັບມັນບໍ່ໄດ້ເປັນຕົວແທນຂອງສິ່ງທີ່ຫນ້າສົນໃຈ, ດັ່ງນັ້ນພິທີກໍາເຫຼົ່ານີ້ຖືກປະໄວ້ພາຍໃຕ້ການ spoiler.

ກຳລັງເພີ່ມລາຍການທົດສອບ

MDB_env *env;
MDB_dbi dbi;
MDB_txn *txn;

mdb_env_create(&env);
mdb_env_open(env, "./testdb", MDB_NOTLS, 0664);

mdb_txn_begin(env, NULL, 0, &txn);
mdb_dbi_open(txn, NULL, 0, &dbi);
mdb_txn_abort(txn);

char k = 'k';
MDB_val key;
key.mv_size = sizeof(k);
key.mv_data = (void *)&k;

int v = 997;
MDB_val value;
value.mv_size = sizeof(v);
value.mv_data = (void *)&v;

mdb_txn_begin(env, NULL, 0, &txn);
mdb_put(txn, dbi, &key, &value, MDB_NOOVERWRITE);
mdb_txn_commit(txn);

MDB_txn *txn1, *txn2, *txn3;
MDB_val val;

// Открываем 2 транзакции, каждая из которых смотрит
// на версию базы данных с одной записью.
mdb_txn_begin(env, NULL, 0, &txn1); // read-write
mdb_txn_begin(env, NULL, MDB_RDONLY, &txn2); // read-only

// В рамках первой транзакции удаляем из базы данных существующую в ней запись.
mdb_del(txn1, dbi, &key, NULL);
// Фиксируем удаление.
mdb_txn_commit(txn1);

// Открываем третью транзакцию, которая смотрит на
// актуальную версию базы данных, где записи уже нет.
mdb_txn_begin(env, NULL, MDB_RDONLY, &txn3);
// Убеждаемся, что запись по искомому ключу уже не существует.
assert(mdb_get(txn3, dbi, &key, &val) == MDB_NOTFOUND);
// Завершаем транзакцию.
mdb_txn_abort(txn3);

// Убеждаемся, что в рамках второй транзакции, открытой на момент
// существования записи в базе данных, её всё ещё можно найти по ключу.
assert(mdb_get(txn2, dbi, &key, &val) == MDB_SUCCESS);
// Проверяем, что по ключу получен не абы какой мусор, а валидные данные.
assert(*(int *)val.mv_data == 997);
// Завершаем транзакцию, работающей хоть и с устаревшей, но консистентной базой данных.
mdb_txn_abort(txn2);

ຂ້ອຍຂໍແນະນໍາໃຫ້ທ່ານພະຍາຍາມ trick ດຽວກັນກັບ SQLite ແລະເບິ່ງວ່າມີຫຍັງເກີດຂື້ນ.

Multiversion ເອົາສິດທິປະໂຫຍດດີໆມາສູ່ຊີວິດຂອງຜູ້ພັດທະນາ iOS. ການນໍາໃຊ້ຄຸນສົມບັດນີ້, ທ່ານສາມາດປັບອັດຕາການປັບປຸງຂອງແຫຼ່ງຂໍ້ມູນສໍາລັບຮູບແບບຫນ້າຈໍໄດ້ຢ່າງງ່າຍດາຍແລະທໍາມະຊາດ, ໂດຍອີງໃສ່ການພິຈາລະນາປະສົບການຂອງຜູ້ໃຊ້. ຕົວຢ່າງ, ໃຫ້ເຮົາໃຊ້ຄຸນສົມບັດຂອງແອັບພລິເຄຊັນ Mail.ru Cloud ເຊັ່ນການໂຫຼດເນື້ອຫາອັດຕະໂນມັດຈາກຄັງສື່ຂອງລະບົບ. ດ້ວຍການເຊື່ອມຕໍ່ທີ່ດີ, ລູກຄ້າສາມາດເພີ່ມຮູບຫຼາຍຮູບຕໍ່ວິນາທີໃສ່ເຄື່ອງແມ່ຂ່າຍ. ຖ້າຫາກວ່າທ່ານປັບປຸງຫຼັງຈາກການດາວໂຫຼດແຕ່ລະຄົນ UICollectionView ດ້ວຍເນື້ອຫາສື່ຢູ່ໃນເມຄຂອງຜູ້ໃຊ້, ທ່ານສາມາດລືມກ່ຽວກັບ 60 fps ແລະການເລື່ອນພາບໃນລະຫວ່າງຂະບວນການນີ້. ເພື່ອປ້ອງກັນການປັບປຸງຫນ້າຈໍເລື້ອຍໆ, ທ່ານ ຈຳ ເປັນຕ້ອງ ຈຳ ກັດອັດຕາການປ່ຽນແປງຂໍ້ມູນໃນພື້ນຖານ UICollectionViewDataSource.

ຖ້າຖານຂໍ້ມູນບໍ່ສະຫນັບສະຫນູນ multiversion ແລະອະນຸຍາດໃຫ້ທ່ານເຮັດວຽກພຽງແຕ່ກັບສະຖານະປະຈຸບັນ, ຫຼັງຈາກນັ້ນ, ເພື່ອສ້າງ snapshot ຄົງເວລາຂອງຂໍ້ມູນ, ທ່ານຈໍາເປັນຕ້ອງຄັດລອກມັນບໍ່ວ່າຈະເປັນບາງໂຄງສ້າງຂໍ້ມູນໃນຫນ່ວຍຄວາມຈໍາຫຼືຕາຕະລາງຊົ່ວຄາວ. ທຸກໆວິທີການເຫຼົ່ານີ້ແມ່ນລາຄາແພງຫຼາຍ. ໃນກໍລະນີຂອງການເກັບຮັກສາໃນຫນ່ວຍຄວາມຈໍາ, ພວກເຮົາໄດ້ຮັບຄ່າໃຊ້ຈ່າຍທັງໃນຫນ່ວຍຄວາມຈໍາ, ທີ່ເກີດຈາກການເກັບຮັກສາວັດຖຸກໍ່ສ້າງ, ແລະໃນເວລາ, ທີ່ກ່ຽວຂ້ອງກັບການຫັນປ່ຽນ ORM ຊ້ໍາຊ້ອນ. ສໍາລັບຕາຕະລາງຊົ່ວຄາວ, ນີ້ແມ່ນຄວາມສຸກທີ່ມີລາຄາແພງກວ່າ, ເຮັດໃຫ້ຄວາມຮູ້ສຶກພຽງແຕ່ໃນກໍລະນີທີ່ບໍ່ສໍາຄັນ.

ການແກ້ໄຂ multiversion ຂອງ LMDB ແກ້ໄຂບັນຫາການຮັກສາແຫຼ່ງຂໍ້ມູນທີ່ມີຄວາມຫມັ້ນຄົງໃນລັກສະນະທີ່ສະຫງ່າງາມ. ມັນພຽງພໍທີ່ຈະເປີດການເຮັດທຸລະກໍາແລະ voila - ຈົນກ່ວາພວກເຮົາສໍາເລັດມັນ, ຊຸດຂໍ້ມູນແມ່ນຮັບປະກັນວ່າຈະຖືກແກ້ໄຂ. ເຫດຜົນສໍາລັບຄວາມໄວການປັບປຸງຂອງມັນໃນປັດຈຸບັນທັງຫມົດແມ່ນຢູ່ໃນມືຂອງຊັ້ນນໍາສະເຫນີ, ໂດຍບໍ່ມີຊັບພະຍາກອນທີ່ສໍາຄັນ.

ຕົວກະພິບ

ຕົວກະພິບສະຫນອງກົນໄກສໍາລັບການ iterating ເປັນລະບຽບໃນໄລຍະຄູ່ທີ່ສໍາຄັນໂດຍຜ່ານ B-Tree traversal. ຖ້າບໍ່ມີພວກມັນ, ມັນກໍ່ເປັນໄປບໍ່ໄດ້ທີ່ຈະສ້າງແບບຈໍາລອງຕາຕະລາງໃນຖານຂໍ້ມູນຢ່າງມີປະສິດທິພາບ, ເຊິ່ງພວກເຮົາຫັນໄປຫາ.

4.2. ການສ້າງແບບຈໍາລອງຕາຕະລາງ

ຄຸນສົມບັດຂອງຄໍາສັ່ງທີ່ສໍາຄັນອະນຸຍາດໃຫ້ທ່ານສ້າງ abstraction ລະດັບສູງເຊັ່ນຕາຕະລາງເທິງຂອງ abstractions ພື້ນຖານ. ໃຫ້ພິຈາລະນາຂະບວນການນີ້ໂດຍໃຊ້ຕົວຢ່າງຂອງຕາຕະລາງຕົ້ນຕໍຂອງລູກຄ້າຟັງ, ເຊິ່ງເກັບຂໍ້ມູນກ່ຽວກັບໄຟລ໌ແລະໂຟນເດີທັງຫມົດຂອງຜູ້ໃຊ້.

ຕາຕະລາງຕາຕະລາງ

ຫນຶ່ງໃນສະຖານະການທົ່ວໄປທີ່ໂຄງສ້າງຕາຕະລາງທີ່ມີຕົ້ນໄມ້ໂຟເດີຄວນຖືກປັບແຕ່ງແມ່ນການເລືອກອົງປະກອບທັງຫມົດທີ່ຢູ່ໃນໄດເລກະທໍລີທີ່ກໍານົດ. ຮູບແບບອົງການຈັດຕັ້ງຂໍ້ມູນທີ່ດີສໍາລັບການສອບຖາມທີ່ມີປະສິດທິພາບຂອງປະເພດນີ້ແມ່ນ. ບັນຊີລາຍຊື່ຄວາມສາມາດ. ເພື່ອປະຕິບັດມັນຢູ່ເທິງສຸດຂອງການເກັບຮັກສາທີ່ສໍາຄັນ, ມັນຈໍາເປັນຕ້ອງຈັດຮຽງຄີຂອງໄຟລ໌ແລະໂຟນເດີ້ຕ່າງໆໃນແບບທີ່ພວກມັນຖືກຈັດເປັນກຸ່ມໂດຍອີງໃສ່ການເປັນສະມາຊິກຂອງພວກເຂົາໃນໄດເລກະທໍລີພໍ່ແມ່. ນອກຈາກນັ້ນ, ເພື່ອສະແດງເນື້ອຫາຂອງໄດເລກະທໍລີໃນຮູບແບບທີ່ຄຸ້ນເຄີຍກັບຜູ້ໃຊ້ Windows (ໂຟເດີທໍາອິດ, ຫຼັງຈາກນັ້ນໄຟລ໌, ທັງສອງຈັດຮຽງຕາມລໍາດັບ), ມັນຈໍາເປັນຕ້ອງໄດ້ລວມເອົາຊ່ອງຂໍ້ມູນເພີ່ມເຕີມທີ່ສອດຄ້ອງກັນໃນຄີ.

ຮູບພາບຂ້າງລຸ່ມນີ້ສະແດງໃຫ້ເຫັນວິທີການ, ໂດຍອີງໃສ່ວຽກງານທີ່ມີຢູ່ໃນມື, ການເປັນຕົວແທນຂອງກະແຈໃນຮູບແບບຂອງ byte array ອາດຈະຄ້າຍຄື. bytes ທີ່ມີຕົວລະບຸຂອງໄດເລກະທໍລີແມ່ (ສີແດງ) ແມ່ນຖືກຈັດໃສ່ກ່ອນ, ຫຼັງຈາກນັ້ນດ້ວຍປະເພດ (ສີຂຽວ) ແລະໃນຫາງທີ່ມີຊື່ (ສີຟ້າ). ວິທີການທີ່ຕ້ອງການ. ຄີ traversing ຕາມລໍາດັບທີ່ມີຄໍານໍາຫນ້າສີແດງດຽວກັນໃຫ້ພວກເຮົາມູນຄ່າທີ່ກ່ຽວຂ້ອງຂອງພວກເຂົາໃນຄໍາສັ່ງທີ່ພວກເຂົາຄວນຈະຖືກສະແດງຢູ່ໃນສ່ວນຕິດຕໍ່ຜູ້ໃຊ້ (ທາງດ້ານຂວາ), ໂດຍບໍ່ມີການຮຽກຮ້ອງໃຫ້ມີການປະມວນຜົນເພີ່ມເຕີມ.

Serializing Keys ແລະຄ່າ

ວິທີການຈໍານວນຫຼາຍສໍາລັບການ serializing ວັດຖຸໄດ້ຖືກ invented ໃນໂລກ. ເນື່ອງຈາກພວກເຮົາບໍ່ມີຄວາມຕ້ອງການອື່ນນອກຈາກຄວາມໄວ, ພວກເຮົາເລືອກໄວທີ່ສຸດທີ່ເປັນໄປໄດ້ສໍາລັບຕົວເຮົາເອງ - ການຖິ້ມຂີ້ເຫຍື້ອຂອງຫນ່ວຍຄວາມຈໍາທີ່ຄອບຄອງໂດຍຕົວຢ່າງຂອງໂຄງສ້າງພາສາ C. ດັ່ງນັ້ນ, ກຸນແຈຂອງອົງປະກອບໄດເລກະທໍລີສາມາດຖືກສ້າງແບບຈໍາລອງດ້ວຍໂຄງສ້າງຕໍ່ໄປນີ້. NodeKey.

typedef struct NodeKey {
    EntityId parentId;
    uint8_t type;
    uint8_t nameBuffer[256];
} NodeKey;

ບັນທຶກ NodeKey ໃນການເກັບຮັກສາທີ່ຈໍາເປັນໃນວັດຖຸ MDB_val ວາງຕົວຊີ້ຂໍ້ມູນໄປຫາທີ່ຢູ່ຂອງການເລີ່ມຕົ້ນຂອງໂຄງສ້າງ, ແລະຄິດໄລ່ຂະຫນາດຂອງພວກເຂົາດ້ວຍຫນ້າທີ່ sizeof.

MDB_val serialize(NodeKey * const key) {
    return MDB_val {
        .mv_size = sizeof(NodeKey),
        .mv_data = (void *)key
    };
}

ໃນບົດທໍາອິດກ່ຽວກັບເງື່ອນໄຂການຄັດເລືອກຖານຂໍ້ມູນ, ຂ້າພະເຈົ້າໄດ້ກ່າວເຖິງການຫຼຸດຜ່ອນການຈັດສັນແບບເຄື່ອນໄຫວພາຍໃນການດໍາເນີນງານ CRUD ເປັນປັດໃຈການຄັດເລືອກທີ່ສໍາຄັນ. ລະຫັດຟັງຊັນ serialize ສະແດງໃຫ້ເຫັນວິທີການໃນກໍລະນີຂອງ LMDB ພວກເຂົາສາມາດຫຼີກເວັ້ນໄດ້ຢ່າງສົມບູນເມື່ອໃສ່ບັນທຶກໃຫມ່ເຂົ້າໄປໃນຖານຂໍ້ມູນ. array byte ຂາເຂົ້າຈາກເຊີບເວີຖືກປ່ຽນເປັນໂຄງສ້າງ stack ທໍາອິດ, ແລະຫຼັງຈາກນັ້ນພວກມັນຈະຖືກ dumped ເຂົ້າໄປໃນບ່ອນເກັບມ້ຽນ. ພິຈາລະນາວ່າບໍ່ມີການຈັດສັນແບບເຄື່ອນໄຫວພາຍໃນ LMDB, ທ່ານສາມາດໄດ້ຮັບສະຖານະການທີ່ດີເລີດໂດຍມາດຕະຖານ iOS - ໃຊ້ພຽງແຕ່ stack memory ເພື່ອເຮັດວຽກກັບຂໍ້ມູນຕາມເສັ້ນທາງທັງຫມົດຈາກເຄືອຂ່າຍໄປຫາແຜ່ນ!

ການສັ່ງກະແຈດ້ວຍຕົວປຽບທຽບຄູ່

ການພົວພັນຄໍາສັ່ງທີ່ສໍາຄັນແມ່ນຖືກກໍານົດໂດຍຫນ້າທີ່ພິເສດທີ່ເອີ້ນວ່າຕົວປຽບທຽບ. ເນື່ອງຈາກເຄື່ອງຈັກບໍ່ຮູ້ຫຍັງກ່ຽວກັບຄວາມຫມາຍຂອງ bytes ທີ່ເຂົາເຈົ້າບັນຈຸ, ຕົວປຽບທຽບໃນຕອນຕົ້ນບໍ່ມີທາງເລືອກນອກ ເໜືອ ຈາກການຈັດລຽງກະແຈໃນ ຄຳ ສັ່ງ lexicographic, ອີງໃສ່ການປຽບທຽບ byte-by-byte. ການນໍາໃຊ້ມັນໃນການຈັດຕັ້ງໂຄງສ້າງແມ່ນຄ້າຍຄືກັບການໂກນຫນວດດ້ວຍຂວານຟັກ. ຢ່າງໃດກໍຕາມ, ໃນກໍລະນີງ່າຍດາຍ, ຂ້າພະເຈົ້າເຫັນວ່າວິທີການນີ້ຍອມຮັບ. ທາງເລືອກແມ່ນໄດ້ອະທິບາຍຂ້າງລຸ່ມນີ້, ແຕ່ໃນທີ່ນີ້ຂ້າພະເຈົ້າຈະສັງເກດເຫັນສອງສາມ rakes ກະແຈກກະຈາຍໄປຕາມເສັ້ນທາງນີ້.

ສິ່ງທໍາອິດທີ່ຕ້ອງຈື່ແມ່ນການເປັນຕົວແທນຂອງຫນ່ວຍຄວາມຈໍາຂອງປະເພດຂໍ້ມູນເບື້ອງຕົ້ນ. ດັ່ງນັ້ນ, ໃນອຸປະກອນ Apple ທັງຫມົດ, ຕົວແປ integer ຖືກເກັບໄວ້ໃນຮູບແບບ Endian ນ້ອຍ. ນີ້ຫມາຍຄວາມວ່າ byte ທີ່ມີຫນ້ອຍທີ່ສຸດຈະຢູ່ເບື້ອງຊ້າຍ, ແລະມັນຈະບໍ່ສາມາດຈັດລຽງຈໍານວນເຕັມໂດຍໃຊ້ການປຽບທຽບ byte-by-byte. ຕົວຢ່າງ, ພະຍາຍາມເຮັດສິ່ງນີ້ດ້ວຍຊຸດຂອງຕົວເລກຈາກ 0 ຫາ 511 ຈະສ້າງຜົນໄດ້ຮັບຕໍ່ໄປນີ້.

// value (hex dump)
000 (0000)
256 (0001)
001 (0100)
257 (0101)
...
254 (fe00)
510 (fe01)
255 (ff00)
511 (ff01)

ເພື່ອແກ້ໄຂບັນຫານີ້, ຈໍານວນເຕັມຕ້ອງຖືກເກັບໄວ້ໃນຄີໃນຮູບແບບທີ່ເຫມາະສົມກັບຕົວປຽບທຽບ byte-byte. ຫນ້າທີ່ຈາກຄອບຄົວຈະຊ່ວຍໃຫ້ທ່ານປະຕິບັດການຫັນປ່ຽນທີ່ຈໍາເປັນ hton* (ໂດຍສະເພາະ htons ສໍາລັບຕົວເລກ double-byte ຈາກຕົວຢ່າງ).

ຮູບແບບສໍາລັບການເປັນຕົວແທນຂອງ strings ໃນການຂຽນໂປລແກລມ, ຕາມທີ່ທ່ານຮູ້, ທັງຫມົດ ປະຫວັດສາດ. ຖ້າ semantics ຂອງ strings, ເຊັ່ນດຽວກັນກັບການເຂົ້າລະຫັດທີ່ໃຊ້ເພື່ອສະແດງໃຫ້ພວກເຂົາຢູ່ໃນຫນ່ວຍຄວາມຈໍາ, ຊີ້ໃຫ້ເຫັນວ່າອາດຈະມີຫຼາຍກວ່າຫນຶ່ງ byte ຕໍ່ຕົວອັກສອນ, ຫຼັງຈາກນັ້ນມັນກໍ່ດີກວ່າທີ່ຈະປະຖິ້ມຄວາມຄິດຂອງການນໍາໃຊ້ຕົວປຽບທຽບໃນຕອນຕົ້ນ.

ສິ່ງທີສອງທີ່ຕ້ອງຢູ່ໃນໃຈແມ່ນ ຫຼັກການຈັດຕັ້ງ ໂຄງສ້າງພາກສະຫນາມ compiler. ເນື່ອງຈາກວ່າພວກເຂົາ, bytes ທີ່ມີຄ່າຂີ້ເຫຍື້ອສາມາດຖືກສ້າງຂື້ນໃນຫນ່ວຍຄວາມຈໍາລະຫວ່າງທົ່ງນາ, ເຊິ່ງ, ແນ່ນອນ, breaks byte-byte sorting. ເພື່ອກໍາຈັດຂີ້ເຫຍື້ອ, ທ່ານຈໍາເປັນຕ້ອງປະກາດທົ່ງນາຕາມລໍາດັບທີ່ກໍານົດໄວ້ຢ່າງເຂັ້ມງວດ, ຮັກສາກົດລະບຽບການຈັດຕໍາແຫນ່ງຢູ່ໃນໃຈ, ຫຼືນໍາໃຊ້ຄຸນລັກສະນະໃນການປະກາດໂຄງສ້າງ. packed.

ການສັ່ງກະແຈດ້ວຍຕົວປຽບທຽບພາຍນອກ

ເຫດຜົນການປຽບທຽບຫຼັກອາດຈະສັບສົນເກີນໄປສຳລັບຕົວປຽບທຽບຄູ່. ຫນຶ່ງໃນຫຼາຍເຫດຜົນແມ່ນການປະກົດຕົວຂອງສາຂາດ້ານວິຊາການພາຍໃນໂຄງສ້າງ. ຂ້າພະເຈົ້າຈະສະແດງໃຫ້ເຫັນເຖິງການປະກົດຕົວຂອງເຂົາເຈົ້າໂດຍໃຊ້ຕົວຢ່າງຂອງຄີສໍາລັບອົງປະກອບຂອງໄດເລກະທໍລີທີ່ຄຸ້ນເຄີຍກັບພວກເຮົາ.

typedef struct NodeKey {
    EntityId parentId;
    uint8_t type;
    uint8_t nameBuffer[256];
} NodeKey;

ເຖິງວ່າຈະມີຄວາມງ່າຍດາຍຂອງມັນ, ໃນກໍລະນີຫຼາຍທີ່ສຸດ, ມັນບໍລິໂພກຄວາມຊົງຈໍາຫຼາຍເກີນໄປ. buffer ສໍາລັບຊື່ໃຊ້ເວລາເຖິງ 256 bytes, ເຖິງແມ່ນວ່າໂດຍສະເລ່ຍໄຟລ໌ແລະຊື່ໂຟນເດີບໍ່ຄ່ອຍຈະເກີນ 20-30 ຕົວອັກສອນ.

ຫນຶ່ງໃນເຕັກນິກມາດຕະຖານສໍາລັບການເພີ່ມປະສິດທິພາບຂະຫນາດຂອງບັນທຶກແມ່ນເພື່ອ "ຕັດ" ມັນກັບຂະຫນາດຕົວຈິງ. ໂດຍເນື້ອແທ້ແລ້ວຂອງມັນແມ່ນເນື້ອໃນຂອງຊ່ອງຂໍ້ມູນຄວາມຍາວຕົວແປທັງຫມົດຖືກເກັບໄວ້ໃນ buffer ໃນຕອນທ້າຍຂອງໂຄງສ້າງ, ແລະຄວາມຍາວຂອງພວກມັນຖືກເກັບໄວ້ໃນຕົວແປແຍກຕ່າງຫາກ. NodeKey ຖືກຫັນເປັນດັ່ງຕໍ່ໄປນີ້.

typedef struct NodeKey {
    EntityId parentId;
    uint8_t type;
    uint8_t nameLength;
    uint8_t nameBuffer[256];
} NodeKey;

ນອກຈາກນັ້ນ, ໃນເວລາທີ່ serializing, ຂະຫນາດຂໍ້ມູນບໍ່ໄດ້ລະບຸ sizeof ໂຄງປະກອບການທັງຫມົດ, ແລະຂະຫນາດຂອງພາກສະຫນາມທັງຫມົດແມ່ນຄວາມຍາວຄົງທີ່ບວກກັບຂະຫນາດຂອງພາກສ່ວນທີ່ໃຊ້ຕົວຈິງຂອງ buffer ໄດ້.

MDB_val serialize(NodeKey * const key) {
    return MDB_val {
        .mv_size = offsetof(NodeKey, nameBuffer) + key->nameLength,
        .mv_data = (void *)key
    };
}

ເປັນຜົນມາຈາກການ refactoring, ພວກເຮົາໄດ້ຮັບການປະຫຍັດທີ່ສໍາຄັນໃນພື້ນທີ່ occupied ໂດຍກະແຈ. ຢ່າງໃດກໍຕາມ, ເນື່ອງຈາກພາກສະຫນາມດ້ານວິຊາການ nameLength, ຕົວປຽບທຽບຖານສອງບໍ່ເໝາະສົມກັບການປຽບທຽບຫຼັກອີກຕໍ່ໄປ. ຖ້າພວກເຮົາບໍ່ປ່ຽນແທນມັນດ້ວຍຕົວເຮົາເອງ, ຄວາມຍາວຂອງຊື່ຈະເປັນປັດໃຈບູລິມະສິດທີ່ສູງກວ່າໃນການຈັດລຽງຂອງຊື່ຂອງມັນເອງ.

LMDB ອະນຸຍາດໃຫ້ແຕ່ລະຖານຂໍ້ມູນມີຫນ້າທີ່ປຽບທຽບທີ່ສໍາຄັນຂອງຕົນເອງ. ນີ້ແມ່ນເຮັດໄດ້ໂດຍໃຊ້ຟັງຊັນ mdb_set_compare ຢ່າງເຂັ້ມງວດກ່ອນທີ່ຈະເປີດ. ສໍາລັບເຫດຜົນທີ່ຊັດເຈນ, ມັນບໍ່ສາມາດປ່ຽນແປງໄດ້ຕະຫຼອດຊີວິດຂອງຖານຂໍ້ມູນ. ຕົວປຽບທຽບໄດ້ຮັບສອງກະແຈໃນຮູບແບບຖານສອງເປັນການປ້ອນຂໍ້ມູນ, ແລະຢູ່ທີ່ຜົນຜະລິດມັນຈະສົ່ງຜົນການປຽບທຽບ: ໜ້ອຍກວ່າ (-1), ຫຼາຍກວ່າ (1) ຫຼືເທົ່າກັບ (0). Pseudocode ສໍາລັບ NodeKey ເບິ່ງຄືວ່າ.

int compare(MDB_val * const a, MDB_val * const b) {
    NodeKey * const aKey = (NodeKey * const)a->mv_data;
    NodeKey * const bKey = (NodeKey * const)b->mv_data;
    return // ...
}

ຕາບໃດທີ່ກະແຈທັງໝົດໃນຖານຂໍ້ມູນມີປະເພດດຽວກັນ, ໂດຍບໍ່ມີເງື່ອນໄຂ, ການສົ່ງສັນຍານໄບຕ໌ຂອງພວກມັນໃຫ້ກັບປະເພດຂອງໂຄງສ້າງຫຼັກຂອງແອັບພລິເຄຊັນແມ່ນຖືກຕ້ອງຕາມກົດໝາຍ. ມີ nuance ຫນຶ່ງຢູ່ທີ່ນີ້, ແຕ່ມັນຈະຖືກປຶກສາຫາລືຂ້າງລຸ່ມນີ້ຢູ່ໃນສ່ວນຍ່ອຍ "Reading Records".

Serializing ຄ່າ

LMDB ເຮັດວຽກຢ່າງເຂັ້ມງວດກັບກະແຈຂອງບັນທຶກທີ່ເກັບໄວ້. ການປຽບທຽບຂອງພວກເຂົາກັບກັນແລະກັນແມ່ນເກີດຂື້ນໃນຂອບຂອງການດໍາເນີນງານທີ່ນໍາໃຊ້, ແລະການປະຕິບັດຂອງການແກ້ໄຂທັງຫມົດແມ່ນຂຶ້ນກັບຄວາມໄວຂອງຜູ້ປຽບທຽບ. ໃນໂລກທີ່ເຫມາະສົມ, ຕົວປຽບທຽບຄູ່ເລີ່ມຕົ້ນຄວນຈະພຽງພໍທີ່ຈະປຽບທຽບກະແຈ, ແຕ່ຖ້າທ່ານຕ້ອງໃຊ້ຕົວຂອງທ່ານເອງ, ຂັ້ນຕອນສໍາລັບການ deserializing ກະແຈໃນມັນຄວນຈະໄວເທົ່າທີ່ຈະໄວໄດ້.

ຖານຂໍ້ມູນບໍ່ມີຄວາມສົນໃຈໂດຍສະເພາະໃນສ່ວນມູນຄ່າຂອງບັນທຶກ (ມູນຄ່າ). ການປ່ຽນຂອງມັນຈາກການເປັນຕົວແທນ byte ເປັນວັດຖຸເກີດຂຶ້ນພຽງແຕ່ໃນເວລາທີ່ມັນຕ້ອງການແລ້ວໂດຍລະຫັດຄໍາຮ້ອງສະຫມັກ, ຕົວຢ່າງ, ເພື່ອສະແດງມັນໃນຫນ້າຈໍ. ເນື່ອງຈາກວ່າມັນເກີດຂຶ້ນຂ້ອນຂ້າງບໍ່ຄ່ອຍ, ຄວາມຕ້ອງການຄວາມໄວສໍາລັບຂັ້ນຕອນນີ້ແມ່ນບໍ່ສໍາຄັນ, ແລະໃນການປະຕິບັດຂອງມັນ, ພວກເຮົາມີອິດສະຫຼະຫຼາຍທີ່ຈະສຸມໃສ່ຄວາມສະດວກສະບາຍ. ສໍາລັບການຍົກຕົວຢ່າງ, ເພື່ອ serialize metadata ກ່ຽວກັບໄຟລ໌ທີ່ຍັງບໍ່ໄດ້ດາວໂຫຼດ, ພວກເຮົາໃຊ້. NSKeyedArchiver.

NSData *data = serialize(object);
MDB_val value = {
    .mv_size = data.length,
    .mv_data = (void *)data.bytes
};

ຢ່າງໃດກໍຕາມ, ມີບາງຄັ້ງທີ່ການປະຕິບັດຍັງສໍາຄັນ. ຕົວຢ່າງ, ເມື່ອບັນທຶກ metaformation ກ່ຽວກັບໂຄງສ້າງໄຟລ໌ຂອງເມຄຜູ້ໃຊ້, ພວກເຮົາໃຊ້ການຖິ້ມຫນ່ວຍຄວາມຈໍາດຽວກັນຂອງວັດຖຸ. ຈຸດເດັ່ນຂອງວຽກງານຂອງການສ້າງການເປັນຕົວແທນ serialized ຂອງພວກເຂົາແມ່ນຄວາມຈິງທີ່ວ່າອົງປະກອບຂອງລະບົບໄດ້ຖືກສ້າງແບບຈໍາລອງໂດຍລໍາດັບຊັ້ນຮຽນ.

ເພື່ອປະຕິບັດມັນໃນພາສາ C, ຂົງເຂດສະເພາະຂອງ heirs ແມ່ນຖືກຈັດໃສ່ໃນໂຄງສ້າງແຍກຕ່າງຫາກ, ແລະການເຊື່ອມຕໍ່ຂອງເຂົາເຈົ້າກັບພື້ນຖານຫນຶ່ງແມ່ນຖືກກໍານົດໂດຍຜ່ານພາກສະຫນາມຂອງສະຫະພັນປະເພດ. ເນື້ອໃນຕົວຈິງຂອງສະຫະພັນແມ່ນໄດ້ລະບຸໄວ້ໂດຍຜ່ານປະເພດຄຸນລັກສະນະດ້ານວິຊາການ.

typedef struct NodeValue {
    EntityId localId;
    EntityType type;
    union {
        FileInfo file;
        DirectoryInfo directory;
    } info;
    uint8_t nameLength;
    uint8_t nameBuffer[256];
} NodeValue;

ເພີ່ມແລະປັບປຸງການບັນທຶກ

ລະຫັດ serialized ແລະມູນຄ່າສາມາດຖືກເພີ່ມໃສ່ຮ້ານ. ເພື່ອເຮັດສິ່ງນີ້, ໃຊ້ຫນ້າທີ່ mdb_put.

// key и value имеют тип MDB_val
mdb_put(..., &key, &value, MDB_NOOVERWRITE);

ໃນຂັ້ນຕອນການຕັ້ງຄ່າ, ການເກັບຮັກສາສາມາດຖືກອະນຸຍາດຫຼືຫ້າມບໍ່ໃຫ້ເກັບຮັກສາບັນທຶກຫຼາຍອັນດ້ວຍລະຫັດດຽວກັນ. ຖ້າການຊໍ້າຊ້ອນຂອງກະແຈຖືກຫ້າມ, ເມື່ອໃສ່ບັນທຶກ, ທ່ານສາມາດກໍານົດວ່າການອັບເດດບັນທຶກທີ່ມີຢູ່ແລ້ວແມ່ນອະນຸຍາດຫຼືບໍ່. ຖ້າຫາກວ່າ fraying ສາມາດເກີດຂຶ້ນພຽງແຕ່ເປັນຜົນມາຈາກຄວາມຜິດພາດຂອງລະຫັດ, ຫຼັງຈາກນັ້ນທ່ານສາມາດປ້ອງກັນຕົວທ່ານເອງຈາກມັນໂດຍການລະບຸທຸງ. NOOVERWRITEທີ່ຢູ່

ການອ່ານລາຍການ

ເພື່ອອ່ານບັນທຶກໃນ LMDB, ໃຊ້ຟັງຊັນ mdb_get. ຖ້າຄູ່ຄີ-ຄ່າຖືກສະແດງໂດຍໂຄງສ້າງທີ່ຖືກຖິ້ມໄວ້ກ່ອນຫນ້ານີ້, ຂັ້ນຕອນນີ້ເບິ່ງຄືວ່ານີ້.

NodeValue * const readNode(..., NodeKey * const key) {
    MDB_val rawKey = serialize(key);
    MDB_val rawValue;
    mdb_get(..., &rawKey, &rawValue);
    return (NodeValue * const)rawValue.mv_data;
}

ບັນຊີລາຍຊື່ທີ່ນໍາສະເຫນີສະແດງໃຫ້ເຫັນວິທີການ serialization ໂດຍຜ່ານການ dump ໂຄງສ້າງຊ່ວຍໃຫ້ທ່ານສາມາດກໍາຈັດການຈັດສັນແບບເຄື່ອນໄຫວບໍ່ພຽງແຕ່ໃນເວລາຂຽນ, ແຕ່ໃນເວລາອ່ານຂໍ້ມູນ. ມາຈາກຟັງຊັນ mdb_get ຕົວຊີ້ເບິ່ງແນ່ນອນທີ່ຢູ່ຫນ່ວຍຄວາມຈໍາ virtual ບ່ອນທີ່ຖານຂໍ້ມູນເກັບຮັກສາການສະແດງ byte ຂອງວັດຖຸ. ໃນຄວາມເປັນຈິງ, ພວກເຮົາໄດ້ຮັບປະເພດຂອງ ORM ທີ່ສະຫນອງຄວາມໄວໃນການອ່ານຂໍ້ມູນສູງຫຼາຍເກືອບບໍ່ເສຍຄ່າ. ເຖິງວ່າຈະມີຄວາມງາມທັງຫມົດຂອງວິທີການ, ມັນຈໍາເປັນຕ້ອງຈື່ຈໍາລັກສະນະຕ່າງໆທີ່ກ່ຽວຂ້ອງກັບມັນ.

ສໍາລັບການເຮັດທຸລະກໍາທີ່ອ່ານເທົ່ານັ້ນ, ຕົວຊີ້ໄປຫາໂຄງສ້າງມູນຄ່າແມ່ນຮັບປະກັນວ່າຍັງຄົງຖືກຕ້ອງຈົນກ່ວາການເຮັດທຸລະກໍາຖືກປິດ. ດັ່ງທີ່ໄດ້ລະບຸໄວ້ກ່ອນຫນ້ານີ້, ຫນ້າ B-tree ທີ່ວັດຖຸຕັ້ງຢູ່, ຂອບໃຈກັບຫຼັກການ copy-on-write, ຍັງຄົງບໍ່ປ່ຽນແປງຕາບໃດທີ່ພວກມັນຖືກອ້າງອີງໂດຍຢ່າງຫນ້ອຍຫນຶ່ງທຸລະກໍາ. ໃນເວລາດຽວກັນ, ທັນທີທີ່ການເຮັດທຸລະກໍາສຸດທ້າຍທີ່ກ່ຽວຂ້ອງກັບພວກມັນສໍາເລັດ, ຫນ້າຕ່າງໆສາມາດຖືກນໍາໃຊ້ຄືນໃຫມ່ສໍາລັບຂໍ້ມູນໃຫມ່. ຖ້າມັນເປັນສິ່ງຈໍາເປັນສໍາລັບວັດຖຸເພື່ອຄວາມຢູ່ລອດຂອງທຸລະກໍາທີ່ສ້າງໃຫ້ເຂົາເຈົ້າ, ຫຼັງຈາກນັ້ນພວກເຂົາຍັງຕ້ອງໄດ້ຮັບການຄັດລອກ.
ສໍາລັບການອ່ານລາຍການ, ຕົວຊີ້ໄປເຖິງໂຄງສ້າງມູນຄ່າທີ່ໄດ້ຮັບຈະຖືກຕ້ອງພຽງແຕ່ຈົນກ່ວາຂັ້ນຕອນການດັດແກ້ຄັ້ງທໍາອິດ (ຂຽນຫຼືລຶບຂໍ້ມູນ).
ເຖິງແມ່ນວ່າໂຄງສ້າງ NodeValue ບໍ່ເຕັມຮູບແບບ, ແຕ່ຖືກຕັດອອກ (ເບິ່ງພາກສ່ວນຍ່ອຍ “ການສັ່ງກະແຈໂດຍໃຊ້ຕົວປຽບທຽບພາຍນອກ”), ທ່ານສາມາດເຂົ້າເຖິງທົ່ງນາຂອງມັນໄດ້ຢ່າງປອດໄພຜ່ານຕົວຊີ້. ສິ່ງທີ່ ສຳ ຄັນບໍ່ແມ່ນການປະຕິເສດມັນ!
ພາຍໃຕ້ສະພາບການໃດໆບໍ່ຄວນດັດແປງໂຄງສ້າງໂດຍຜ່ານຕົວຊີ້ທີ່ໄດ້ຮັບ. ການປ່ຽນແປງທັງຫມົດຕ້ອງເຮັດໂດຍຜ່ານວິທີການເທົ່ານັ້ນ mdb_put. ຢ່າງໃດກໍຕາມ, ບໍ່ວ່າທ່ານຕ້ອງການເຮັດອັນນີ້ຍາກປານໃດ, ມັນເປັນໄປບໍ່ໄດ້, ເພາະວ່າພື້ນທີ່ຫນ່ວຍຄວາມຈໍາທີ່ໂຄງສ້າງນີ້ຕັ້ງຢູ່ແມ່ນແຜນທີ່ຢູ່ໃນໂຫມດອ່ານເທົ່ານັ້ນ.
Remap ໄຟລ໌ໄປຫາພື້ນທີ່ທີ່ຢູ່ຂອງຂະບວນການສໍາລັບຈຸດປະສົງຂອງຕົວຢ່າງເຊັ່ນການເພີ່ມຂະຫນາດການເກັບຮັກສາສູງສຸດໂດຍໃຊ້ຟັງຊັນ mdb_env_set_map_size invalidates ທຸລະກໍາທັງຫມົດແລະຫນ່ວຍງານທີ່ກ່ຽວຂ້ອງໂດຍທົ່ວໄປແລະຊີ້ໄປຫາວັດຖຸສະເພາະໃດຫນຶ່ງໂດຍສະເພາະ.

ສຸດທ້າຍ, ລັກສະນະອື່ນແມ່ນ insidious ສະນັ້ນການເປີດເຜີຍເນື້ອໃນຂອງມັນບໍ່ເຫມາະສົມກັບພຽງແຕ່ວັກອື່ນ. ໃນບົດກ່ຽວກັບຕົ້ນໄມ້ B, ຂ້າພະເຈົ້າໄດ້ໃຫ້ແຜນວາດວິທີການຈັດລຽງຫນ້າຂອງມັນຢູ່ໃນຄວາມຊົງຈໍາ. ມັນປະຕິບັດຕາມນີ້ວ່າທີ່ຢູ່ຂອງການເລີ່ມຕົ້ນຂອງ buffer ທີ່ມີຂໍ້ມູນ serialized ສາມາດ arbitrary ຢ່າງແທ້ຈິງ. ເນື່ອງຈາກວ່ານີ້, ຕົວຊີ້ໃຫ້ພວກເຂົາໄດ້ຮັບໃນໂຄງສ້າງ MDB_val ແລະຫຼຸດລົງເປັນຕົວຊີ້ໄປຫາໂຄງສ້າງ, ມັນຈະກາຍເປັນ unaligned ໃນກໍລະນີທົ່ວໄປ. ໃນຂະນະດຽວກັນ, ສະຖາປັດຕະຍະກໍາຂອງບາງຊິບ (ໃນກໍລະນີຂອງ iOS ນີ້ແມ່ນ armv7) ຮຽກຮ້ອງໃຫ້ທີ່ຢູ່ຂອງຂໍ້ມູນໃດຫນຶ່ງເປັນຄວາມຫຼາກຫຼາຍຂອງຂະຫນາດຂອງຄໍາສັບເຄື່ອງຈັກຫຼື, ໃນຄໍາສັບຕ່າງໆອື່ນໆ, ຂະຫນາດບິດຂອງລະບົບ (. ສໍາລັບ armv7 ມັນແມ່ນ 32 bits). ໃນຄໍາສັບຕ່າງໆອື່ນໆ, ການດໍາເນີນງານເຊັ່ນ: *(int *foo)0x800002 ກ່ຽວກັບພວກເຂົາແມ່ນເທົ່າກັບການຫນີແລະນໍາໄປສູ່ການປະຕິບັດທີ່ມີຄໍາຕັດສິນ EXC_ARM_DA_ALIGN. ມີສອງວິທີທີ່ຈະຫຼີກລ້ຽງຊະຕາກໍາທີ່ໂສກເສົ້າດັ່ງກ່າວ.

ທໍາອິດຕົ້ມລົງໄປຫາການຄັດລອກຂໍ້ມູນເບື້ອງຕົ້ນເຂົ້າໄປໃນໂຄງສ້າງທີ່ສອດຄ່ອງກັນຢ່າງຈະແຈ້ງ. ຕົວຢ່າງ, ໃນຕົວປຽບທຽບທີ່ກໍາຫນົດເອງນີ້ຈະຖືກສະທ້ອນໃຫ້ເຫັນດັ່ງຕໍ່ໄປນີ້.

int compare(MDB_val * const a, MDB_val * const b) {
    NodeKey aKey, bKey;
    memcpy(&aKey, a->mv_data, a->mv_size);
    memcpy(&bKey, b->mv_data, b->mv_size);
    return // ...
}

ອີກວິທີໜຶ່ງຄືການແຈ້ງໃຫ້ຜູ້ສັງລວມຂໍ້ມູນລ່ວງໜ້າວ່າໂຄງສ້າງຂອງຄ່າຫຼັກອາດບໍ່ສອດຄ່ອງຕາມຄຸນລັກສະນະ. aligned(1). ໃນ ARM ທ່ານສາມາດມີຜົນກະທົບດຽວກັນ ບັນລຸ ແລະການນໍາໃຊ້ຄຸນລັກສະນະບັນຈຸ. ພິຈາລະນາວ່າມັນຍັງຊ່ວຍເພີ່ມປະສິດທິພາບພື້ນທີ່ທີ່ຖືກຄອບຄອງໂດຍໂຄງສ້າງ, ວິທີການນີ້ເບິ່ງຄືວ່າຂ້ອຍມັກ, ເຖິງແມ່ນວ່າ. ປະເພດ ການເພີ່ມຂຶ້ນຂອງຄ່າໃຊ້ຈ່າຍໃນການດໍາເນີນງານການເຂົ້າເຖິງຂໍ້ມູນ.

typedef struct __attribute__((packed)) NodeKey {
    uint8_t parentId;
    uint8_t type;
    uint8_t nameLength;
    uint8_t nameBuffer[256];
} NodeKey;

ໄລຍະການສອບຖາມ

ເພື່ອເຮັດຊ້ຳໃນກຸ່ມບັນທຶກ, LMDB ສະໜອງຕົວຊີ້ຕົວກະພິບ. ໃຫ້ເບິ່ງວິທີການເຮັດວຽກກັບມັນໂດຍໃຊ້ຕົວຢ່າງຂອງຕາຕະລາງທີ່ມີ metadata cloud ຜູ້ໃຊ້ທີ່ຄຸ້ນເຄີຍກັບພວກເຮົາ.

ເປັນສ່ວນຫນຶ່ງຂອງການສະແດງລາຍການໄຟລ໌ໃນໄດເລກະທໍລີ, ມັນຈໍາເປັນຕ້ອງຊອກຫາຄີທັງຫມົດທີ່ໄຟລ໌ແລະໂຟນເດີ້ລູກຂອງມັນມີຄວາມກ່ຽວຂ້ອງ. ໃນພາກຍ່ອຍທີ່ຜ່ານມາພວກເຮົາໄດ້ຈັດຮຽງຄີ NodeKey ດັ່ງ ນັ້ນ ພວກ ເຂົາ ເຈົ້າ ໄດ້ ຖືກ ລໍາ ດັບ ຕົ້ນ ຕໍ ໂດຍ ID ຂອງ ລະ ບົບ ພໍ່ ແມ່. ດັ່ງນັ້ນ, ທາງດ້ານເຕັກນິກ, ວຽກງານຂອງການດຶງເອົາເນື້ອໃນຂອງໂຟນເດີມາລົງເພື່ອວາງຕົວກະພິບຢູ່ໃນເຂດແດນເທິງຂອງກຸ່ມຂອງຄີທີ່ມີຄໍານໍາຫນ້າທີ່ໃຫ້ແລະຫຼັງຈາກນັ້ນ iterating ກັບເຂດແດນຕ່ໍາ.

ຂອບເຂດເທິງສາມາດພົບໄດ້ໂດຍກົງໂດຍການຄົ້ນຫາຕາມລໍາດັບ. ເພື່ອເຮັດສິ່ງນີ້, ຕົວກະພິບຖືກວາງໄວ້ໃນຕອນຕົ້ນຂອງບັນຊີລາຍຊື່ທັງຫມົດຂອງກະແຈໃນຖານຂໍ້ມູນແລະເພີ່ມຂຶ້ນຕື່ມອີກຈົນກ່ວາກະແຈທີ່ມີຕົວລະບຸຂອງໄດເລກະທໍລີພໍ່ແມ່ປາກົດຢູ່ດ້ານລຸ່ມ. ວິທີການນີ້ມີ 2 ຂໍ້ເສຍທີ່ຈະແຈ້ງ:

ຄວາມສັບສົນໃນການຄົ້ນຫາເສັ້ນ, ເຖິງແມ່ນວ່າ, ຕາມທີ່ຮູ້, ໃນຕົ້ນໄມ້ໂດຍທົ່ວໄປແລະໃນຕົ້ນໄມ້ B, ໂດຍສະເພາະມັນສາມາດປະຕິບັດໄດ້ໃນເວລາ logarithmic.
ໄຮ້ປະໂຫຍດ, ທຸກຫນ້າກ່ອນຫນ້າຫນຶ່ງທີ່ກໍາລັງຊອກຫາແມ່ນຖືກຍົກຈາກໄຟລ໌ໄປຫາຫນ່ວຍຄວາມຈໍາຕົ້ນຕໍ, ເຊິ່ງມີລາຄາແພງທີ່ສຸດ.

ໂຊກດີ, LMDB API ສະຫນອງວິທີການທີ່ມີປະສິດທິພາບໃນການວາງຕົວກະພິບໃນເບື້ອງຕົ້ນ. ຕົວຢ່າງ, ກ່ຽວຂ້ອງກັບບັນຊີລາຍຊື່ໃນຮູບຂ້າງເທິງ, ພວກເຮົາສາມາດເຮັດໃຫ້ສໍາຄັນໃນພາກສະຫນາມ parentId ຈະເທົ່າກັບ 2, ແລະສ່ວນທີ່ເຫຼືອທັງໝົດແມ່ນເຕັມໄປດ້ວຍສູນ. ກະແຈທີ່ເຕັມໄປບາງສ່ວນແມ່ນສະໜອງໃຫ້ກັບການປ້ອນຂໍ້ມູນຟັງຊັນ mdb_cursor_get ຊີ້ບອກການດໍາເນີນງານ MDB_SET_RANGEທີ່ຢູ່

NodeKey upperBoundSearchKey = {
    .parentId = 2,
    .type = 0,
    .nameLength = 0
};
MDB_val value, key = serialize(upperBoundSearchKey);
MDB_cursor *cursor;
mdb_cursor_open(..., &cursor);
mdb_cursor_get(cursor, &key, &value, MDB_SET_RANGE);

ຖ້າເຂດແດນເທິງຂອງກຸ່ມຂອງກະແຈຖືກພົບເຫັນ, ຫຼັງຈາກນັ້ນພວກເຮົາເຮັດຊ້ໍາມັນຈົນກວ່າພວກເຮົາຈະພົບກັນຫຼືກະແຈພົບກັນ. parentIdຫຼືກະແຈຈະບໍ່ໝົດ.

do {
    rc = mdb_cursor_get(cursor, &key, &value, MDB_NEXT);
    // processing...
} while (MDB_NOTFOUND != rc && // check end of table
         IsTargetKey(key));    // check end of keys group

ສິ່ງທີ່ດີແມ່ນວ່າເປັນສ່ວນຫນຶ່ງຂອງການເຮັດຊ້ໍາໂດຍໃຊ້ mdb_cursor_get, ພວກເຮົາບໍ່ພຽງແຕ່ໄດ້ຮັບລະຫັດ, ແຕ່ຍັງມີມູນຄ່າ. ຖ້າ, ເພື່ອປະຕິບັດເງື່ອນໄຂການເກັບຕົວຢ່າງ, ທ່ານຈໍາເປັນຕ້ອງກວດເບິ່ງ, ໃນບັນດາສິ່ງອື່ນໆ, ທົ່ງນາຈາກສ່ວນມູນຄ່າຂອງບັນທຶກ, ຫຼັງຈາກນັ້ນພວກມັນສາມາດເຂົ້າເຖິງໄດ້ໂດຍບໍ່ມີທ່າທາງເພີ່ມເຕີມ.

4.3. ການສ້າງແບບຈໍາລອງຄວາມສໍາພັນລະຫວ່າງຕາຕະລາງ

ໂດຍໃນປັດຈຸບັນ, ພວກເຮົາໄດ້ຈັດການພິຈາລະນາທຸກດ້ານຂອງການອອກແບບແລະເຮັດວຽກກັບຖານຂໍ້ມູນຕາຕະລາງດຽວ. ພວກເຮົາສາມາດເວົ້າໄດ້ວ່າຕາຕະລາງແມ່ນຊຸດຂອງບັນທຶກການຈັດຮຽງທີ່ປະກອບດ້ວຍປະເພດດຽວກັນຂອງຄູ່ຄີມູນຄ່າ. ຖ້າທ່ານສະແດງຄີເປັນຮູບສີ່ຫລ່ຽມແລະຄ່າທີ່ກ່ຽວຂ້ອງເປັນ parallelepiped, ທ່ານຈະໄດ້ຮັບແຜນວາດພາບຂອງຖານຂໍ້ມູນ.

'' '"

ແນວໃດກໍ່ຕາມ, ໃນຊີວິດຈິງມັນບໍ່ຄ່ອຍເປັນໄປໄດ້ທີ່ຈະໄດ້ຮັບການໂດຍການນອງເລືອດເລັກນ້ອຍ. ເລື້ອຍໆໃນຖານຂໍ້ມູນມັນຈໍາເປັນຕ້ອງມີ, ກ່ອນອື່ນ ໝົດ, ຕ້ອງມີຕາຕະລາງຫຼາຍ, ແລະອັນທີສອງ, ເພື່ອເຮັດໃຫ້ການເລືອກໃນພວກມັນຕາມລໍາດັບທີ່ແຕກຕ່າງຈາກລະຫັດຫຼັກ. ພາກສຸດທ້າຍນີ້ແມ່ນອຸທິດໃຫ້ກັບບັນຫາຂອງການສ້າງແລະການເຊື່ອມຕໍ່ກັນຂອງເຂົາເຈົ້າ.

ຕາຕະລາງດັດສະນີ

ແອັບພລິເຄຊັນຄລາວມີສ່ວນ "Gallery". ມັນສະແດງເນື້ອຫາສື່ຈາກຟັງທັງໝົດ, ຈັດຮຽງຕາມວັນທີ. ເພື່ອປະຕິບັດການເລືອກດັ່ງກ່າວໃຫ້ດີທີ່ສຸດ, ຕໍ່ໄປກັບຕາຕະລາງຕົ້ນຕໍ, ທ່ານຈໍາເປັນຕ້ອງສ້າງລະຫັດໃຫມ່ທີ່ມີປະເພດໃຫມ່. ພວກມັນຈະມີຊ່ອງຂໍ້ມູນທີ່ມີວັນທີທີ່ໄຟລ໌ຖືກສ້າງຂຶ້ນ, ເຊິ່ງຈະເຮັດຫນ້າທີ່ເປັນເງື່ອນໄຂການຈັດລຽງຕົ້ນຕໍ. ເນື່ອງຈາກວ່າກະແຈໃຫມ່ອ້າງອີງຂໍ້ມູນດຽວກັນກັບກະແຈໃນຕາຕະລາງຕົ້ນຕໍ, ພວກມັນຖືກເອີ້ນວ່າກະແຈດັດສະນີ. ໃນຮູບຂ້າງລຸ່ມນີ້ພວກເຂົາຖືກເນັ້ນໃສ່ໃນສີສົ້ມ.

ເພື່ອແຍກກະແຈຂອງຕາຕະລາງທີ່ແຕກຕ່າງກັນອອກຈາກກັນພາຍໃນຖານຂໍ້ມູນດຽວກັນ, tableId ດ້ານເຕັກນິກເພີ່ມເຕີມໄດ້ຖືກເພີ່ມໃສ່ພວກມັນທັງຫມົດ. ໂດຍການເຮັດໃຫ້ມັນເປັນບູລິມະສິດສູງສຸດສໍາລັບການຈັດຮຽງ, ພວກເຮົາຈະບັນລຸການຈັດກຸ່ມຂອງຄີທໍາອິດໂດຍຕາຕະລາງ, ແລະພາຍໃນຕາຕະລາງ - ຕາມກົດລະບຽບຂອງພວກເຮົາ.

ກະແຈດັດສະນີອ້າງອີງຂໍ້ມູນດຽວກັນກັບກະແຈຫຼັກ. ການປະຕິບັດຢ່າງກົງໄປກົງມາຂອງຊັບສິນນີ້ໂດຍຜ່ານການເຊື່ອມໂຍງກັບມັນກັບສໍາເນົາຂອງສ່ວນມູນຄ່າຂອງກຸນແຈຕົ້ນຕໍແມ່ນບໍ່ເຫມາະສົມຈາກຫຼາຍຈຸດ:

ໃນແງ່ຂອງການເອົາພື້ນທີ່, metadata ສາມາດຂ້ອນຂ້າງອຸດົມສົມບູນ.
ຈາກທັດສະນະການປະຕິບັດ, ນັບຕັ້ງແຕ່ເມື່ອປັບປຸງ metadata ຂອງ node, ທ່ານຈະຕ້ອງຂຽນຄືນໃຫມ່ໂດຍໃຊ້ສອງປຸ່ມ.
ຈາກທັດສະນະຂອງການສະຫນັບສະຫນູນລະຫັດ, ຖ້າພວກເຮົາລືມປັບປຸງຂໍ້ມູນສໍາລັບຫນຶ່ງໃນລະຫັດ, ພວກເຮົາຈະໄດ້ຮັບຂໍ້ບົກພ່ອງຂອງຂໍ້ມູນທີ່ບໍ່ສອດຄ່ອງກັນໃນການເກັບຮັກສາ.

ຕໍ່ໄປ, ພວກເຮົາຈະພິຈາລະນາວິທີການລົບລ້າງຂໍ້ບົກຜ່ອງເຫຼົ່ານີ້.

ການຈັດຕັ້ງການພົວພັນລະຫວ່າງຕາຕະລາງ

ຮູບແບບແມ່ນເຫມາະສົມດີສໍາລັບການເຊື່ອມໂຍງຕາຕະລາງດັດສະນີກັບຕາຕະລາງຕົ້ນຕໍ "ກະແຈເປັນມູນຄ່າ". ດັ່ງທີ່ຊື່ຂອງມັນຊີ້ໃຫ້ເຫັນ, ສ່ວນມູນຄ່າຂອງບັນທຶກດັດສະນີແມ່ນສໍາເນົາຂອງມູນຄ່າຫຼັກຕົ້ນຕໍ. ວິທີການນີ້ກໍາຈັດທຸກຂໍ້ເສຍທີ່ໄດ້ກ່າວມາຂ້າງເທິງທີ່ກ່ຽວຂ້ອງກັບການເກັບຮັກສາສໍາເນົາຂອງສ່ວນມູນຄ່າຂອງບັນທຶກຕົ້ນຕໍ. ຄ່າໃຊ້ຈ່າຍພຽງແຕ່ວ່າເພື່ອໃຫ້ໄດ້ມູນຄ່າໂດຍລະຫັດດັດສະນີ, ທ່ານຈໍາເປັນຕ້ອງເຮັດ 2 ຄໍາຖາມໄປຫາຖານຂໍ້ມູນແທນທີ່ຈະເປັນຫນຶ່ງ. schematically, schema ຖານຂໍ້ມູນຜົນໄດ້ຮັບເບິ່ງຄືວ່ານີ້.

ຮູບແບບອື່ນສໍາລັບການຈັດການພົວພັນລະຫວ່າງຕາຕະລາງແມ່ນ "ກະແຈຊ້ຳຊ້ອນ". ໂດຍເນື້ອແທ້ແລ້ວຂອງມັນແມ່ນການເພີ່ມຄຸນລັກສະນະເພີ່ມເຕີມໃຫ້ກັບກະແຈ, ເຊິ່ງບໍ່ຈໍາເປັນສໍາລັບການຈັດຮຽງ, ແຕ່ສໍາລັບການສ້າງລະຫັດທີ່ກ່ຽວຂ້ອງຄືນໃຫມ່. ສະພາບການຂອງໂຄງການ iOS ສະເພາະ, ຂ້າພະເຈົ້າຈະໃຫ້ເປັນ fictitious, ແຕ່ວ່າຕົວຢ່າງທີ່ຈະແຈ້ງກວ່າ.

ລູກຄ້າມືຖືຄລາວມີຫນ້າທີ່ສະແດງໄຟລ໌ແລະໂຟນເດີທັງຫມົດທີ່ຜູ້ໃຊ້ໄດ້ແບ່ງປັນກັບຄົນອື່ນ. ເນື່ອງຈາກວ່າມີໄຟລ໌ດັ່ງກ່າວຂ້ອນຂ້າງຫນ້ອຍ, ແລະມີຫຼາຍປະເພດທີ່ແຕກຕ່າງກັນຂອງຂໍ້ມູນສະເພາະກ່ຽວກັບການເຜີຍແຜ່ທີ່ກ່ຽວຂ້ອງກັບພວກເຂົາ (ຜູ້ທີ່ໄດ້ຮັບອະນຸຍາດ, ມີສິດທິຫຍັງ, ແລະອື່ນໆ), ມັນຈະບໍ່ສົມເຫດສົມຜົນທີ່ຈະພາລະສ່ວນມູນຄ່າຂອງ. ບັນທຶກໃນຕາຕະລາງຕົ້ນຕໍກັບມັນ. ຢ່າງໃດກໍຕາມ, ຖ້າທ່ານຕ້ອງການສະແດງໄຟລ໌ດັ່ງກ່າວແບບອອບໄລນ໌, ທ່ານຍັງຈໍາເປັນຕ້ອງເກັບຮັກສາມັນຢູ່ບ່ອນໃດບ່ອນຫນຶ່ງ. ການແກ້ໄຂທໍາມະຊາດແມ່ນການສ້າງຕາຕະລາງແຍກຕ່າງຫາກສໍາລັບມັນ. ໃນແຜນວາດຂ້າງລຸ່ມນີ້, ຄີຂອງມັນຖືກນໍາຫນ້າດ້ວຍ "P", ແລະຕົວຍຶດ "propname" ສາມາດຖືກແທນທີ່ດ້ວຍມູນຄ່າສະເພາະ "ຂໍ້ມູນສາທາລະນະ".

metadata ທີ່ເປັນເອກະລັກທັງຫມົດ, ສໍາລັບ sake ຂອງການເກັບຮັກສາທີ່ຕາຕະລາງໃຫມ່ໄດ້ຖືກສ້າງຂື້ນ, ແມ່ນຖືກຈັດໃສ່ໃນສ່ວນມູນຄ່າຂອງບັນທຶກ. ໃນເວລາດຽວກັນ, ທ່ານບໍ່ຕ້ອງການທີ່ຈະຊ້ໍາກັນຂໍ້ມູນກ່ຽວກັບໄຟລ໌ແລະໂຟນເດີທີ່ເກັບໄວ້ໃນຕາຕະລາງຕົ້ນຕໍ. ແທນທີ່ຈະ, ຂໍ້ມູນທີ່ຊ້ໍາກັນຈະຖືກເພີ່ມໃສ່ປຸ່ມ "P" ໃນຮູບແບບຂອງຊ່ອງຂໍ້ມູນ "node ID" ແລະ "timestamp". ຂໍຂອບໃຈກັບພວກເຂົາ, ທ່ານສາມາດສ້າງລະຫັດດັດສະນີ, ຈາກທີ່ທ່ານສາມາດໄດ້ຮັບລະຫັດຕົ້ນຕໍ, ຈາກນັ້ນ, ສຸດທ້າຍ, ທ່ານສາມາດໄດ້ຮັບ node metadata.

ສະຫຼຸບ

ພວກເຮົາປະເມີນຜົນໄດ້ຮັບຂອງການປະຕິບັດ LMDB ໃນທາງບວກ. ຫຼັງຈາກທີ່ມັນ, ຈໍານວນຂອງຄໍາຮ້ອງສະຫມັກ freezes ຫຼຸດລົງໂດຍ 30%.

ຜົນໄດ້ຮັບຂອງການເຮັດວຽກເຮັດໄດ້ resonated ເກີນກວ່າທີມງານ iOS. ໃນປັດຈຸບັນ, ຫນຶ່ງໃນພາກສ່ວນ "Files" ຕົ້ນຕໍໃນແອັບພລິເຄຊັນ Android ຍັງໄດ້ປ່ຽນໄປໃຊ້ LMDB, ແລະພາກສ່ວນອື່ນໆແມ່ນຢູ່ໃນທາງ. ພາສາ C, ທີ່ເກັບຮັກສາ key-value ໄດ້ຖືກປະຕິບັດ, ເປັນການຊ່ວຍເຫຼືອທີ່ດີໃນການສ້າງໂຄງຮ່າງການຄໍາຮ້ອງສະຫມັກປະມານມັນຂ້າມເວທີໃນ C ++. ເຄື່ອງສ້າງລະຫັດຖືກນໍາໃຊ້ເພື່ອເຊື່ອມຕໍ່ຫ້ອງສະຫມຸດ C ++ ທີ່ເປັນຜົນມາຈາກລະຫັດເວທີໃນ Objective-C ແລະ Kotlin. ດີຈິນນີ ຈາກ Dropbox, ແຕ່ນັ້ນແມ່ນເລື່ອງທີ່ແຕກຕ່າງກັນຫມົດ.

ແຫຼ່ງຂໍ້ມູນ: www.habr.com

ຄວາມສະຫວ່າງແລະຄວາມທຸກຍາກຂອງຖານຂໍ້ມູນທີ່ສໍາຄັນ LMDB ໃນແອັບພລິເຄຊັນ iOS

ເນື້ອໃນ

1. ແຮງຈູງໃຈໃນການຈັດຕັ້ງປະຕິບັດ

2. ການຈັດຕໍາແໜ່ງ LMDB

3. ສາມເສົາຄ້ຳຂອງ LMDB

3.1. ປາວານ #1. ໄຟລ໌ທີ່ມີແຜນທີ່ດ້ວຍໜ່ວຍຄວາມຈຳ

ຂໍ້ມູນທົ່ວໄປກ່ຽວກັບໄຟລ໌ທີ່ມີແຜນທີ່ຫນ່ວຍຄວາມຈໍາ

ຂໍ້ມູນສະເພາະຂອງໄຟລ໌ທີ່ມີແຜນທີ່ຄວາມຈຳໃນ iOS

3.2. ປາວານ #2. B+-ຕົ້ນໄມ້

3.3. ປາວານ #3. ສຳເນົາ-ຂຽນ

4. ການອອກແບບໂຄງຮ່າງຂໍ້ມູນຢູ່ເທິງສຸດຂອງ key-value API

4.1. ບົດຄັດຫຍໍ້ພື້ນຖານ

ສະພາບແວດລ້ອມ

ຖານຂໍ້ມູນ

ຄີ ແລະຄ່າ

ການເຮັດທຸລະ ກຳ

ຕົວກະພິບ

4.2. ການສ້າງແບບຈໍາລອງຕາຕະລາງ

ຕາຕະລາງຕາຕະລາງ

Serializing Keys ແລະຄ່າ

ການສັ່ງກະແຈດ້ວຍຕົວປຽບທຽບຄູ່

ການສັ່ງກະແຈດ້ວຍຕົວປຽບທຽບພາຍນອກ

Serializing ຄ່າ

ເພີ່ມແລະປັບປຸງການບັນທຶກ

ການອ່ານລາຍການ

ໄລຍະການສອບຖາມ

4.3. ການສ້າງແບບຈໍາລອງຄວາມສໍາພັນລະຫວ່າງຕາຕະລາງ

ຕາຕະລາງດັດສະນີ

ການຈັດຕັ້ງການພົວພັນລະຫວ່າງຕາຕະລາງ

ສະຫຼຸບ

ເພີ່ມຄວາມຄິດເຫັນ Отменитьответ

ຄວາມສະຫວ່າງແລະຄວາມທຸກຍາກຂອງຖານຂໍ້ມູນທີ່ສໍາຄັນ LMDB ໃນແອັບພລິເຄຊັນ iOS

ເນື້ອໃນ

1. ແຮງຈູງໃຈໃນການຈັດຕັ້ງປະຕິບັດ

2. ການຈັດຕໍາແໜ່ງ LMDB

3. ສາມເສົາຄ້ຳຂອງ LMDB

3.1. ປາວານ #1. ໄຟລ໌ທີ່ມີແຜນທີ່ດ້ວຍໜ່ວຍຄວາມຈຳ

ຂໍ້ມູນທົ່ວໄປກ່ຽວກັບໄຟລ໌ທີ່ມີແຜນທີ່ຫນ່ວຍຄວາມຈໍາ

ຂໍ້ມູນສະເພາະຂອງໄຟລ໌ທີ່ມີແຜນທີ່ຄວາມຈຳໃນ iOS

3.2. ປາວານ #2. B+-ຕົ້ນໄມ້

3.3. ປາວານ #3. ສຳເນົາ-ຂຽນ

4. ການອອກແບບໂຄງຮ່າງຂໍ້ມູນຢູ່ເທິງສຸດຂອງ key-value API

4.1. ບົດຄັດຫຍໍ້ພື້ນຖານ

ສະພາບແວດລ້ອມ

ຖານຂໍ້ມູນ

ຄີ ແລະຄ່າ

ການເຮັດທຸລະ ກຳ

ຕົວກະພິບ

4.2. ການສ້າງແບບຈໍາລອງຕາຕະລາງ

ຕາຕະລາງຕາຕະລາງ

Serializing Keys ແລະຄ່າ

ການສັ່ງກະແຈດ້ວຍຕົວປຽບທຽບຄູ່

ການສັ່ງກະແຈດ້ວຍຕົວປຽບທຽບພາຍນອກ

Serializing ຄ່າ

ເພີ່ມ​ແລະ​ປັບ​ປຸງ​ການ​ບັນ​ທຶກ​

ການອ່ານລາຍການ

ໄລຍະການສອບຖາມ

4.3. ການສ້າງແບບຈໍາລອງຄວາມສໍາພັນລະຫວ່າງຕາຕະລາງ

ຕາຕະລາງດັດສະນີ

ການຈັດຕັ້ງການພົວພັນລະຫວ່າງຕາຕະລາງ

ສະ​ຫຼຸບ

ເພີ່ມຄວາມຄິດເຫັນ Отменитьответ

ເພີ່ມແລະປັບປຸງການບັນທຶກ

ສະຫຼຸບ