Basic query[edit]The core usage of

Basic query[edit]
The core usage of the Chord protocol is to query a key from a client (generally a node as well), i.e. to find {displaystyle successor(k)} successor(k). The basic approach is to pass the query to a node's successor, if it cannot find the key locally. This will lead to a {displaystyle O(N)} O(N) query time.

Finger table[edit]
To avoid the linear search above, Chord implements a faster search method by requiring each node to keep a finger table containing up to {displaystyle m} m entries. The {displaystyle i^{th}} i^{th} entry of node {displaystyle n} n will contain {displaystyle successor((n+2^{i-1}),{mod {,}}2^{m})} successor((n+2^{i-1}),mod,2^m). The first entry of finger table is actually the node's immediate successor (and therefore an extra successor field is not needed). Every time a node wants to look up a key {displaystyle k} k, it will pass the query to the closest successor or predecessor (depending on the finger table) of {displaystyle k} k in its finger table (the "largest" one on the circle whose ID is smaller than {displaystyle k} k), until a node finds out the key is stored in its immediate successor.

With such a finger table, the number of nodes that must be contacted to find a successor in an N-node network is {displaystyle O(log N)} O(log N). (See proof below.)

Node join[edit]
Whenever a new node joins, three invariants should be maintained (the first two ensure correctness and the last one keeps querying fast):

Each node's successor points to its immediate successor correctly.
Each key is stored in {displaystyle successor(k)} successor(k).
Each node's finger table should be correct.
To satisfy these invariants, a predecessor field is maintained for each node. As the successor is the first entry of the finger table, we do not need to maintain this field separately any more. The following tasks should be done for a newly joined node {displaystyle n} n:

Initialize node {displaystyle n} n (the predecessor and the finger table).
Notify other nodes to update their predecessors and finger tables.
The new node takes over its responsible keys from its successor.
The predecessor of {displaystyle n} n can be easily obtained from the predecessor of {displaystyle successor(n)} successor(n) (in the previous circle). As for its finger table, there are various initialization methods. The simplest one is to execute find successor queries for all {displaystyle m} m entries, resulting in {displaystyle O(Mlog N)} O(Mlog N) initialization time. A better method is to check whether {displaystyle i^{th}} i^{th} entry in the finger table is still correct for the {displaystyle (i+1)^{th}} (i+1)^{th} entry. This will lead to {displaystyle O(log ^{2}N)} O(log^2 N). The best method is to initialize the finger table from its immediate neighbours and make some updates, which is {displaystyle O(log N)} O(log N).

Stabilization[edit]
To ensure correct lookups, all successor pointers must be up to date. => stabilization protocol running periodically in the background. Updates finger tables and successor pointers. Stabilization protocol: Stabilize(): n asks its successor for its predecessor p and decides whether p should be n‘s successor instead (this is the case if p recently joined the system). Notify(): notifies n‘s successor of its existence, so it can change its predecessor to n Fix_fingers(): updates finger tables

Failures and replication[edit]

ผลลัพธ์ (ไทย) 1:

สอบถามพื้นฐาน [แก้]การใช้งานหลักของโพรโทคอคอร์ดเป็น การสอบถามจากไคลเอนต์ (โดยทั่วไปโหนดเช่น) เช่น การค้นหา successor(k) {displaystyle successor(k) } วิธีพื้นฐานคือการ ผ่านแบบสอบถามไปยังโหนสืบ หากไม่พบคีย์ในท้องถิ่น นี้จะนำไปสู่เวลาสอบถาม O(N) {displaystyle O(N) }ตารางนิ้ว [แก้]เพื่อหลีกเลี่ยงการค้นหาเชิงเส้นข้าง คอร์ดใช้วิธีการค้นหาได้เร็วขึ้น โดยให้แต่ละโหนเก็บตารางนิ้วที่ประกอบด้วยถึงรายการ m {displaystyle m } ของ { displaystyle ฉัน ^ {th } } ผม ^ {th } รายการของโหน {displaystyle n } n จะประกอบด้วย {สืบ displaystyle ((n + 2 ^ { i-1 }) , {mod {,}}2^{m }) } successor((n+2^{i-1}),mod,2^m) รายการแรกของตารางนิ้วเป็นจริงของโหนดที่ทำต่อทันที (และดังนั้น ฟิลด์สืบพิเศษไม่จำเป็นต้อง) ทุกครั้งที่โหนดที่ต้องการค้นหาคีย์ {displaystyle k } k จะส่งแบบสอบถามสืบที่ใกล้เคียงหรือรุ่นก่อนหน้า (ขึ้นอยู่กับตารางนิ้ว) ของ k {displaystyle k } ในตารางนิ้ว (หนึ่ง "ที่ใหญ่ที่สุด" ในวงกลมที่มีหมายเลขที่มีขนาดเล็กกว่า k {displaystyle k }) จนกว่าจะพบโหน คีย์ถูกเก็บไว้ในทำการต่อได้ทันทีเช่นนิ้วตาราง หมายเลขของโหนที่ต้องติดต่อเพื่อค้นหาทายาทในเครือข่ายที่มี N โหน เป็น {displaystyle O(log N) } O (log N) (ดูหลักฐานด้านล่าง)เข้าร่วมโหน [แก้]เมื่อโหนใหม่รวม ควรรักษาสาม invariants (สองคนแรกตรวจความถูกต้อง และสุดท้ายช่วยทำแบบสอบถามอย่างรวดเร็ว):แต่ละโหนสืบไปทดทันทีอย่างถูกต้องแต่ละคีย์ถูกเก็บไว้ใน successor(k) {displaystyle successor(k) }แต่ละโหนตารางนิ้วควรถูกต้องการตอบสนองเหล่านี้ invariants เขตข้อมูลก่อนหน้าถูกรักษาไว้สำหรับแต่ละโหน สืบต่อเป็น รายการแรกของตารางนิ้ว เราไม่จำเป็นต้องรักษาฟิลด์นี้แยกต่างหากใด ๆ เพิ่มเติม ควรทำงานต่อไป n:โหนใหม่รวม {displaystyle n }เริ่มต้นโหน {displaystyle n } n (บรรพบุรุษและตารางนิ้ว)แจ้งโหนอื่น ๆ การปรับปรุงรุ่นก่อนและตารางนิ้วโหนดใหม่จะกว่าคีย์ความรับผิดชอบจากผู้สืบบรรพบุรุษของ {displaystyle n } n สามารถได้รับจากบรรพบุรุษของ {displaystyle successor(n) } successor(n) (ในวงกลมก่อนหน้านี้)ได้อย่างง่ายดาย สำหรับตารางนิ้ว มีหลายวิธี ง่ายที่สุดคือการดำเนินการหาผู้สืบทอดแบบสอบถามสำหรับรายการทั้งหมด {displaystyle m } m ในเวลาเริ่มต้นของ {displaystyle O(Mlog N) } O (Mlog N) วิธีดีคือการ ตรวจสอบว่า { displaystyle ฉัน ^ {th } } ผม ^ {th } รายการในตารางนิ้วจะยังคงถูกต้องสำหรับการ { displaystyle (ผม + 1) ^ {th } } (ผม + 1) ^ {th } รายการ นี้จะนำไปสู่ {displaystyle O(log ^{2}N) } O (log^2 N) วิธีที่ดีที่สุดคือการ เตรียมใช้งานตารางนิ้วจากของเพื่อนบ้านได้ทันที และทำการปรับปรุงบางอย่าง ซึ่งเป็น {displaystyle O(log N) } O (log N)Stabilization[edit]To ensure correct lookups, all successor pointers must be up to date. => stabilization protocol running periodically in the background. Updates finger tables and successor pointers. Stabilization protocol: Stabilize(): n asks its successor for its predecessor p and decides whether p should be n‘s successor instead (this is the case if p recently joined the system). Notify(): notifies n‘s successor of its existence, so it can change its predecessor to n Fix_fingers(): updates finger tablesFailures and replication[edit]

ผลลัพธ์ (ไทย) 2:

แบบสอบถามพื้นฐาน [แก้ไข]
การใช้งานหลักของโพรโทคอคอร์ดคือการค้นหาคีย์จากไคลเอนต์ (โดยทั่วไปโหนดเช่นกัน) คือจะหา { displaystyle ทายาท (k)} ทายาท (k) วิธีการขั้นพื้นฐานคือการผ่านแบบสอบถามไปยังทายาทของโหนดถ้ามันไม่สามารถหาที่สำคัญในประเทศ นี้จะนำไปสู่การ { displaystyle O (n)} O (n) แบบสอบถามเวลา.

ตารางนิ้ว [แก้ไข]
เพื่อหลีกเลี่ยงการค้นหาเชิงเส้นข้างต้นคอร์ดดำเนินวิธีการค้นหาได้เร็วขึ้นโดยกำหนดให้แต่ละโหนดเพื่อให้ตารางนิ้วที่มีถึง { displaystyle m} รายการ M ว่า { displaystyle ฉัน ^ {TH}} ฉัน ^ {TH} รายการของโหนด { displaystyle n} n จะมี { displaystyle ทายาท ((N + 2 ^ {i-1}) { BMOD {, }} 2 ^ {m})} ทายาท ((n + 2 ^ {i-1}) , BMOD , ^ 2 เมตร) รายการแรกของตารางนิ้วเป็นจริงทายาททันทีโหนด (และดังนั้นจึงสนามทายาทพิเศษไม่จำเป็น) เวลาโหนดต้องการที่จะมองขึ้นคีย์ { displaystyle K} K ทุกคนก็จะผ่านแบบสอบถามไปยังผู้สืบทอดที่อยู่ใกล้หรือบรรพบุรุษ (ขึ้นอยู่กับตารางนิ้ว) ของ { displaystyle K} K ในตารางนิ้วของตน (ที่ "ใหญ่ที่สุด "หนึ่งในวงกลมที่มีหมายเลขมีขนาดเล็กกว่า { displaystyle K} k) จนกว่าโหนดพบที่สำคัญคือการเก็บไว้ในทายาทของมันทันที.

ด้วยเช่นตารางนิ้วจำนวนโหนดที่จะต้องได้รับการติดต่อเพื่อหาผู้สืบทอด ในเครือข่าย N-โหนด { displaystyle O ( log n)} O ( log n) (ดูหลักฐานด้านล่าง.)

โหนดเข้าร่วม [แก้ไข]
เมื่อใดก็ตามที่โหนดใหม่เข้าร่วมสามคงที่ควรได้รับการเก็บรักษาไว้ (สองคนแรกให้แน่ใจว่าถูกต้องและคนสุดท้ายที่ช่วยให้การสอบถามเร็ว):

น. ของแต่ละโหนดจุดทายาทผู้สืบทอดของมันทันทีอย่างถูกต้อง
ที่สำคัญแต่ละคนเป็น เก็บไว้ใน { displaystyle ทายาท (k)} ทายาท (k).
ตารางนิ้วของแต่ละโหนดควรถูกต้อง.
เพื่อตอบสนองความคงที่เหล่าฟิลด์บรรพบุรุษจะถูกเก็บไว้สำหรับแต่ละโหนด เป็นผู้สืบทอดเป็นรายการแรกของตารางนิ้วที่เราไม่จำเป็นต้องรักษาข้อมูลนี้แยกใด ๆ เพิ่มเติม งานต่อไปนี้ควรจะทำสำหรับโหนดเข้าร่วมใหม่ { displaystyle n} N:

เริ่มต้นโหนด { displaystyle n} N (บรรพบุรุษและตารางนิ้ว).
แจ้งโหนดอื่น ๆ เพื่ออัปเดตก่อนหน้าและตารางนิ้วของพวกเขา.
โหนดใหม่จะใช้เวลา กุญแจความรับผิดชอบจากทายาท.
บรรพบุรุษของ { displaystyle n} n สามารถรับได้อย่างง่ายดายจากบรรพบุรุษของ { displaystyle ทายาท (n)} ทายาท (n) (ในวงกลมก่อนหน้านี้) ในฐานะที่เป็นสำหรับตารางนิ้วของมันมีวิธีการเริ่มต้นต่างๆ ที่ง่ายที่สุดคือการดำเนินการหาผู้สืบทอดคำสั่งสำหรับทุก { displaystyle m} รายการ M ผลใน { displaystyle O (M log n)} O (M log n) เวลาของการเริ่มต้น วิธีที่ดีกว่าคือการตรวจสอบว่า { displaystyle ฉัน ^ {TH}} ฉัน ^ {TH} รายการในตารางนิ้วยังคงเป็นที่ถูกต้องสำหรับ { displaystyle (i + 1) ^ {TH}} (i + 1) ^ {TH} รายการ นี้จะนำไปสู่การ { displaystyle O ( Log ^ {2} N)} O ( Log ^ 2 N) วิธีที่ดีที่สุดคือการเริ่มต้นตารางนิ้วจากเพื่อนบ้านทันทีและทำให้การปรับปรุงบางอย่างซึ่งเป็น { displaystyle O ( log n)} O ( log n).

การสั่นไหว [แก้ไข]
เพื่อให้แน่ใจว่า lookups ถูกต้องทุกตัวชี้ทายาทต้อง ถึงวันที่ => โปรโตคอลการรักษาเสถียรภาพการทำงานเป็นระยะ ๆ ในพื้นหลัง อัพเดทตารางนิ้วและตัวชี้ทายาท โปรโตคอลการรักษาเสถียรภาพ: ความมั่นคง (): ยังไม่มีขอให้ทายาทของบรรพบุรุษ P และ P ตัดสินใจว่าควรจะ n พุทธางกูรแทน (เป็นกรณีที่ถ้า P เพิ่งเข้าร่วมระบบนี้) แจ้ง (): แจ้งทายาท n ของการดำรงอยู่ของมันจึงสามารถเปลี่ยนรุ่นก่อนถึง n Fix_fingers (): การปรับปรุงตารางนิ้ว

ความล้มเหลวและการจำลองแบบ [แก้ไข]

ผลลัพธ์ (ไทย) 3:

[ แก้ไข ] แบบสอบถามเบื้องต้นหลักการใช้งานของคอร์ด ( แบบสอบถามคีย์จากลูกค้า ( โดยทั่วไปโหนดเช่นกัน ) นั่นคือ หา displaystyle ( K ) } { ทายาทผู้สืบทอด ( K ) แนวคิดพื้นฐานคือการส่งแบบสอบถามไปยังทายาทของโหนด หากไม่สามารถหากุญแจสำคัญในประเทศ นี้จะนำไปสู่ { displaystyle O ( n ) } O ( n ) เวลาสอบถามนิ้วโต๊ะ [ แก้ไข ]หลีกเลี่ยงเส้นตรงค้นหาข้างบน คอร์ด ใช้วิธีค้นหาได้เร็วขึ้น โดยให้แต่ละโหนดเก็บตารางนิ้วที่มีถึง { M } M displaystyle รายการ { displaystyle ผม ^ ^ { { th } } ฉันรายการของโหนด TH } { n } n displaystyle จะประกอบด้วย displaystyle ผู้สืบทอด ( N + { 2 ^ { i-1 } ) { mod { } } 2 ^ , { M } ) } ผู้สืบทอด ( ( n + 2 ^ { } mod i-1 ) 2 ^ m ) รายการแรกของตารางนิ้วจริงๆ ของโหนดทันที ( และดังนั้นจึงเป็นทายาทผู้สืบทอดด้านเสริมไม่ต้องการ ) เวลาที่ทุกโหนดที่ต้องการหา คีย์ displaystyle K } { K ก็จะส่งแบบสอบถามไปยังทายาทใกล้หรือบรรพบุรุษ ( ขึ้นอยู่กับนิ้วโต๊ะ ) { displaystyle K } K ในนิ้วโต๊ะ ( " ใหญ่ที่สุด " หนึ่งบนวงกลมซึ่งมีขนาดเล็กกว่า displaystyle ID { K } K ) จนกว่าโหนดพบว่าคีย์จะถูกเก็บไว้ในตำแหน่งของมันทันทีด้วยเช่นนิ้วตาราง จำนวนของจุดที่ต้องมีการติดต่อหาผู้สืบทอดใน n-node เครือข่าย { displaystyle O ( log n ) } O ( log n ) ( ดูหลักฐานด้านล่าง )โหนดร่วม [ แก้ไข ]เมื่อใดก็ตามที่โหนดใหม่รวม 3 ผลยืนยงควรจะรักษา ( สองคนแรกตรวจสอบความถูกต้องและสุดท้ายเก็บข้อมูลได้อย่างรวดเร็ว )ของโหนดในแต่ละจุดของผู้สืบทอดทายาททันทีได้อย่างถูกต้องแต่ละคีย์จะถูกเก็บไว้ใน displaystyle ( K ) } { ทายาทผู้สืบทอด ( K )ของโหนดแต่ละนิ้วโต๊ะควรจะถูกต้องเพื่อตอบสนองผลยืนยงเหล่านี้ บรรพบุรุษเขตมีการรักษาสำหรับแต่ละโหนด ในฐานะทายาท คือ รายการแรกของนิ้วตาราง เราไม่ต้องการการรักษาด้านนี้แยกต่างหากอีก งานต่อไปนี้ควรทำสำหรับโหนดใหม่เข้าร่วม { displaystyle n } N :เริ่มต้นโหนด { displaystyle n } N ( บรรพบุรุษและนิ้วโต๊ะ )แจ้งจุดอื่น ๆเพื่อปรับปรุงรุ่นก่อนของพวกเขาและตารางนิ้วโหนดใหม่จะใช้เวลามากกว่าการรับผิดชอบคีย์จากทายาทของบรรพบุรุษของ { N } n displaystyle สามารถหาได้ง่ายจากบรรพบุรุษของ displaystyle ( N ) } { ทายาทผู้สืบทอด ( N ) ( ในวงกลมก่อนหน้า ) ส่วนของนิ้วตาราง มีวิธีการเริ่มต้นต่างๆ หนึ่งที่ง่ายที่สุดคือการค้นหาผู้สืบทอดแบบสอบถามทั้งหมด { M } M displaystyle รายการ ส่งผลให้ { displaystyle O ( mlog n ) } O ( mlog n ) เวลาเริ่มต้น . วิธีที่ดีกว่าคือการตรวจสอบว่า displaystyle ผม ^ { { th } } ^ { งาม } รายการในนิ้วโต๊ะยังคงถูกต้องสำหรับ { displaystyle ( + 1 ) ^ { งาม } } ( i + 1 ) ^ { งาม } รายการ นี้จะนำไปสู่การ { displaystyle O ( log ^ { 2 } } O ( log n ) ^ 2 n ) วิธีที่ดีที่สุดคือการเริ่มต้นนิ้วโต๊ะจากประเทศเพื่อนบ้านและทำให้การปรับปรุงบางอย่างซึ่งเป็น { displaystyle O ( log n ) } O ( log n )เสถียรภาพ [ แก้ไข ]เพื่อให้แน่ใจว่า การค้นหาที่ถูกต้อง ชี้ทายาททั้งหมดจะต้องถึงวันที่ = > การปรับปรุงโปรโตคอลวิ่งเป็นระยะ ๆในพื้นหลัง การปรับปรุงตารางนิ้วชี้และผู้สืบทอด โพรโทคอลความมั่นคง : stabilize() : ขอให้ทายาทของบรรพบุรุษของ P และตัดสินใจว่าควรจะ n p สืบทอดแทน ( เป็นกรณีนี้ถ้า P เมื่อเร็ว ๆนี้เข้าร่วมในระบบ ) notify() : แจ้ง N สืบทอดการดำรงอยู่ของมัน มันสามารถเปลี่ยนรุ่นกับ fix_fingers() : การปรับปรุงนิ้วตารางความล้มเหลวและการแก้ไข ]