- ข้อความ
- ประวัติศาสตร์
Cuckoo Hashing, Theory and Practice
Cuckoo Hashing, Theory and Practice : Part 1
One recent line of research I've really been enjoying is the work on cuckoo hashing variants. Currently, my graduate student Adam Kirsch and I are working on a submission tackling the question of how to design cuckoo hashing variants that are more practical in the setting of hardware implementation, such as for routers. So this gives me an excuse to write about cuckoo hashing, explain the problems we see in applying them in practice, and describe the interesting theoretical and practical questions that result. I'll do this over a series of posts.
To start, let us recall the basics of the power of two choices, or multiple-choice hashing. In the standard setting, we are hashing n elements into a hash table with n buckets. Normally, we would hash each item once to determine its bucket; this gives a maximum load, or largest number of elements in any bucket, of about log n / log log n. (All the results I state hold with high probability, so I'll avoid repeating the phrase.) Suppose instead we use two hash functions, giving two choices of locations for each element. Elements are sequentially placed in the least loaded of their two buckets. When we do a lookup, we'll now have to look in two places for the item. In return, the maximum load now falls to about log log n / log 2 -- we've got an extra log in there! (With d > 2 choices, the maximum load would be log log n / log d, just a constant factor better than d = 2.) Results of this type are due to Azar, Broder, Karlin, and Upfal, in their paper Balanced Allocations. (There was some earlier work with a similar result by Karp, Luby, and Meyer auf der Heide.)
In the course of these results, the question arose as to whether one could do better if placing the elements offline. That is, if you had all n elements and their hashes in advance, could you place each element in one of their bucket choices and achieve a better load than the O(log log n) obtained by the sequential placement? The answer turns out to be yes. The best placement only has a constant maximum load. Another way to think of this is to say that if we place the elements sequentially, but retain the power to move them later, as long as each element ends up at one of its bucket choices, we could get down to constant maximum load.
The idea of cuckoo hashing is that such movements can actually be done online quite efficiently. Cuckoo hashing is, essentially, multiple-choice hashing plus moves, and it appears very effective. Let us consider an extreme case, analyzed in the original Cuckoo Hashing paper by Pagh and Rodler. (If my description is unsatisfactory, there is a good explanation already on Wikipedia!) Each bucket can contain just 1 item, and we will have n buckets, split into two subtables of size n/2. Each element has one choice of bucket in each subtable, where the choices are given by independent hash functions. Each hashed element resides at one of its two choices. A lookup therefore always requires at most two accesses into the hash table.
What to do, however, on an insertion -- what if both spaces for an item are already full? When we insert a new item, we put it in the first subtable. If another item is already there, we kick it out, and make it move to the second subtable. If another item is already there, we kick it out, and make it move back to the first table, and so on. This is where the name cuckoo hashing comes from; as the Wikipedia article says,
The name derives from the behavior of some species of cuckoo, where the mother bird pushes eggs out of another bird's nest to lay her own.
Pagh and Rodler prove that if the number of elements inserted is at most (1/2 - epsilon)n for some constant epsilon, then this process finishes in constant expected time! In other words, one can achieve memory utilization of up to 50 percent of capacity, with guaranteed constant lookup time and average constant insertion time.
Further variants significantly improve the memory utilization that can be achieved. Specifically, allowing more than two choices of location helps (more choices of where to go), as does having more than one item per bucket (more choices of what to move). Memory utilization of over 90 percent is easily possible in practice. This paper and this one have more information.
That summarizes the theoretical background, and hopefully convinces you that the idea of cuckoo hashing is a good one. In the next post, we'll look at why you might want to implement cuckoo hashing in hardware, and what obstacles lie therein.
One recent line of research I've really been enjoying is the work on cuckoo hashing variants. Currently, my graduate student Adam Kirsch and I are working on a submission tackling the question of how to design cuckoo hashing variants that are more practical in the setting of hardware implementation, such as for routers. So this gives me an excuse to write about cuckoo hashing, explain the problems we see in applying them in practice, and describe the interesting theoretical and practical questions that result. I'll do this over a series of posts.
To start, let us recall the basics of the power of two choices, or multiple-choice hashing. In the standard setting, we are hashing n elements into a hash table with n buckets. Normally, we would hash each item once to determine its bucket; this gives a maximum load, or largest number of elements in any bucket, of about log n / log log n. (All the results I state hold with high probability, so I'll avoid repeating the phrase.) Suppose instead we use two hash functions, giving two choices of locations for each element. Elements are sequentially placed in the least loaded of their two buckets. When we do a lookup, we'll now have to look in two places for the item. In return, the maximum load now falls to about log log n / log 2 -- we've got an extra log in there! (With d > 2 choices, the maximum load would be log log n / log d, just a constant factor better than d = 2.) Results of this type are due to Azar, Broder, Karlin, and Upfal, in their paper Balanced Allocations. (There was some earlier work with a similar result by Karp, Luby, and Meyer auf der Heide.)
In the course of these results, the question arose as to whether one could do better if placing the elements offline. That is, if you had all n elements and their hashes in advance, could you place each element in one of their bucket choices and achieve a better load than the O(log log n) obtained by the sequential placement? The answer turns out to be yes. The best placement only has a constant maximum load. Another way to think of this is to say that if we place the elements sequentially, but retain the power to move them later, as long as each element ends up at one of its bucket choices, we could get down to constant maximum load.
The idea of cuckoo hashing is that such movements can actually be done online quite efficiently. Cuckoo hashing is, essentially, multiple-choice hashing plus moves, and it appears very effective. Let us consider an extreme case, analyzed in the original Cuckoo Hashing paper by Pagh and Rodler. (If my description is unsatisfactory, there is a good explanation already on Wikipedia!) Each bucket can contain just 1 item, and we will have n buckets, split into two subtables of size n/2. Each element has one choice of bucket in each subtable, where the choices are given by independent hash functions. Each hashed element resides at one of its two choices. A lookup therefore always requires at most two accesses into the hash table.
What to do, however, on an insertion -- what if both spaces for an item are already full? When we insert a new item, we put it in the first subtable. If another item is already there, we kick it out, and make it move to the second subtable. If another item is already there, we kick it out, and make it move back to the first table, and so on. This is where the name cuckoo hashing comes from; as the Wikipedia article says,
The name derives from the behavior of some species of cuckoo, where the mother bird pushes eggs out of another bird's nest to lay her own.
Pagh and Rodler prove that if the number of elements inserted is at most (1/2 - epsilon)n for some constant epsilon, then this process finishes in constant expected time! In other words, one can achieve memory utilization of up to 50 percent of capacity, with guaranteed constant lookup time and average constant insertion time.
Further variants significantly improve the memory utilization that can be achieved. Specifically, allowing more than two choices of location helps (more choices of where to go), as does having more than one item per bucket (more choices of what to move). Memory utilization of over 90 percent is easily possible in practice. This paper and this one have more information.
That summarizes the theoretical background, and hopefully convinces you that the idea of cuckoo hashing is a good one. In the next post, we'll look at why you might want to implement cuckoo hashing in hardware, and what obstacles lie therein.
0/5000
Cuckoo Hashing, Theory and Practice : Part 1
One recent line of research I've really been enjoying is the work on cuckoo hashing variants. Currently, my graduate student Adam Kirsch and I are working on a submission tackling the question of how to design cuckoo hashing variants that are more practical in the setting of hardware implementation, such as for routers. So this gives me an excuse to write about cuckoo hashing, explain the problems we see in applying them in practice, and describe the interesting theoretical and practical questions that result. I'll do this over a series of posts.
To start, let us recall the basics of the power of two choices, or multiple-choice hashing. In the standard setting, we are hashing n elements into a hash table with n buckets. Normally, we would hash each item once to determine its bucket; this gives a maximum load, or largest number of elements in any bucket, of about log n / log log n. (All the results I state hold with high probability, so I'll avoid repeating the phrase.) Suppose instead we use two hash functions, giving two choices of locations for each element. Elements are sequentially placed in the least loaded of their two buckets. When we do a lookup, we'll now have to look in two places for the item. In return, the maximum load now falls to about log log n / log 2 -- we've got an extra log in there! (With d > 2 choices, the maximum load would be log log n / log d, just a constant factor better than d = 2.) Results of this type are due to Azar, Broder, Karlin, and Upfal, in their paper Balanced Allocations. (There was some earlier work with a similar result by Karp, Luby, and Meyer auf der Heide.)
In the course of these results, the question arose as to whether one could do better if placing the elements offline. That is, if you had all n elements and their hashes in advance, could you place each element in one of their bucket choices and achieve a better load than the O(log log n) obtained by the sequential placement? The answer turns out to be yes. The best placement only has a constant maximum load. Another way to think of this is to say that if we place the elements sequentially, but retain the power to move them later, as long as each element ends up at one of its bucket choices, we could get down to constant maximum load.
The idea of cuckoo hashing is that such movements can actually be done online quite efficiently. Cuckoo hashing is, essentially, multiple-choice hashing plus moves, and it appears very effective. Let us consider an extreme case, analyzed in the original Cuckoo Hashing paper by Pagh and Rodler. (If my description is unsatisfactory, there is a good explanation already on Wikipedia!) Each bucket can contain just 1 item, and we will have n buckets, split into two subtables of size n/2. Each element has one choice of bucket in each subtable, where the choices are given by independent hash functions. Each hashed element resides at one of its two choices. A lookup therefore always requires at most two accesses into the hash table.
What to do, however, on an insertion -- what if both spaces for an item are already full? When we insert a new item, we put it in the first subtable. If another item is already there, we kick it out, and make it move to the second subtable. If another item is already there, we kick it out, and make it move back to the first table, and so on. This is where the name cuckoo hashing comes from; as the Wikipedia article says,
The name derives from the behavior of some species of cuckoo, where the mother bird pushes eggs out of another bird's nest to lay her own.
Pagh and Rodler prove that if the number of elements inserted is at most (1/2 - epsilon)n for some constant epsilon, then this process finishes in constant expected time! In other words, one can achieve memory utilization of up to 50 percent of capacity, with guaranteed constant lookup time and average constant insertion time.
Further variants significantly improve the memory utilization that can be achieved. Specifically, allowing more than two choices of location helps (more choices of where to go), as does having more than one item per bucket (more choices of what to move). Memory utilization of over 90 percent is easily possible in practice. This paper and this one have more information.
That summarizes the theoretical background, and hopefully convinces you that the idea of cuckoo hashing is a good one. In the next post, we'll look at why you might want to implement cuckoo hashing in hardware, and what obstacles lie therein.
One recent line of research I've really been enjoying is the work on cuckoo hashing variants. Currently, my graduate student Adam Kirsch and I are working on a submission tackling the question of how to design cuckoo hashing variants that are more practical in the setting of hardware implementation, such as for routers. So this gives me an excuse to write about cuckoo hashing, explain the problems we see in applying them in practice, and describe the interesting theoretical and practical questions that result. I'll do this over a series of posts.
To start, let us recall the basics of the power of two choices, or multiple-choice hashing. In the standard setting, we are hashing n elements into a hash table with n buckets. Normally, we would hash each item once to determine its bucket; this gives a maximum load, or largest number of elements in any bucket, of about log n / log log n. (All the results I state hold with high probability, so I'll avoid repeating the phrase.) Suppose instead we use two hash functions, giving two choices of locations for each element. Elements are sequentially placed in the least loaded of their two buckets. When we do a lookup, we'll now have to look in two places for the item. In return, the maximum load now falls to about log log n / log 2 -- we've got an extra log in there! (With d > 2 choices, the maximum load would be log log n / log d, just a constant factor better than d = 2.) Results of this type are due to Azar, Broder, Karlin, and Upfal, in their paper Balanced Allocations. (There was some earlier work with a similar result by Karp, Luby, and Meyer auf der Heide.)
In the course of these results, the question arose as to whether one could do better if placing the elements offline. That is, if you had all n elements and their hashes in advance, could you place each element in one of their bucket choices and achieve a better load than the O(log log n) obtained by the sequential placement? The answer turns out to be yes. The best placement only has a constant maximum load. Another way to think of this is to say that if we place the elements sequentially, but retain the power to move them later, as long as each element ends up at one of its bucket choices, we could get down to constant maximum load.
The idea of cuckoo hashing is that such movements can actually be done online quite efficiently. Cuckoo hashing is, essentially, multiple-choice hashing plus moves, and it appears very effective. Let us consider an extreme case, analyzed in the original Cuckoo Hashing paper by Pagh and Rodler. (If my description is unsatisfactory, there is a good explanation already on Wikipedia!) Each bucket can contain just 1 item, and we will have n buckets, split into two subtables of size n/2. Each element has one choice of bucket in each subtable, where the choices are given by independent hash functions. Each hashed element resides at one of its two choices. A lookup therefore always requires at most two accesses into the hash table.
What to do, however, on an insertion -- what if both spaces for an item are already full? When we insert a new item, we put it in the first subtable. If another item is already there, we kick it out, and make it move to the second subtable. If another item is already there, we kick it out, and make it move back to the first table, and so on. This is where the name cuckoo hashing comes from; as the Wikipedia article says,
The name derives from the behavior of some species of cuckoo, where the mother bird pushes eggs out of another bird's nest to lay her own.
Pagh and Rodler prove that if the number of elements inserted is at most (1/2 - epsilon)n for some constant epsilon, then this process finishes in constant expected time! In other words, one can achieve memory utilization of up to 50 percent of capacity, with guaranteed constant lookup time and average constant insertion time.
Further variants significantly improve the memory utilization that can be achieved. Specifically, allowing more than two choices of location helps (more choices of where to go), as does having more than one item per bucket (more choices of what to move). Memory utilization of over 90 percent is easily possible in practice. This paper and this one have more information.
That summarizes the theoretical background, and hopefully convinces you that the idea of cuckoo hashing is a good one. In the next post, we'll look at why you might want to implement cuckoo hashing in hardware, and what obstacles lie therein.
การแปล กรุณารอสักครู่..
นกกาเหว่า Hashing, ทฤษฎีและการปฏิบัติ: 1 ส่วน
หนึ่งสายที่ผ่านมาของการวิจัยที่ฉันได้รับความสุขจริงๆคือการทำงานในสายพันธุ์นกกาเหว่าคร่ำเครียด ปัจจุบันจบการศึกษานักเรียนของฉันอดัม Kirsch และฉันกำลังทำงานในการแก้ปัญหาการส่งคำถามของวิธีการออกแบบสายพันธุ์คร่ำเครียดนกกาเหว่าที่มีการปฏิบัติมากขึ้นในการตั้งค่าของการใช้ฮาร์ดแวร์เช่นสำหรับเราเตอร์ ดังนั้นนี่ทำให้ผมมีข้ออ้างที่จะเขียนเกี่ยวกับคร่ำเครียดนกกาเหว่าอธิบายปัญหาที่เราเห็นในนำมาใช้ในทางปฏิบัติและอธิบายคำถามทางทฤษฎีและปฏิบัติที่น่าสนใจที่มีผล ฉันจะทำมากกว่านี้ชุดของการโพสต์. ในการเริ่มต้นให้เราจำพื้นฐานของอำนาจของสองทางเลือกหรือคร่ำเครียดแบบปรนัย ในการตั้งค่ามาตรฐานที่เรากำลัง hashing องค์ประกอบ n ลงในตารางแฮชกับถัง n ปกติเราจะสับแต่ละรายการหนึ่งครั้งเพื่อตรวจสอบถังของตน นี้จะช่วยให้โหลดสูงสุดหรือจำนวนที่ใหญ่ที่สุดขององค์ประกอบในถังใด ๆ เกี่ยวกับการล็อกของ n / log log n (ทุกผลที่ฉันรัฐถือมีโอกาสสูงดังนั้นฉันจะหลีกเลี่ยงการทำซ้ำวลี.) สมมติว่าเราใช้แทนสองฟังก์ชั่นให้สองทางเลือกของสถานที่สำหรับแต่ละองค์ประกอบ องค์ประกอบที่มีอยู่ตามลำดับในการโหลดน้อยที่สุดของสองถังของพวกเขา เมื่อเราทำค้นหาตอนนี้เราจะต้องดูในสถานที่สองของรายการ ในการกลับไปโหลดสูงสุดในขณะนี้ตกอยู่กับเกี่ยวกับการล็อกล็อก n / log 2 - เราได้มีการบันทึกการพิเศษในการมี! (ด้วยการพัฒนา> 2 ตัวเลือกโหลดสูงสุดจะบันทึก log n / ล็อกงเพียงปัจจัยคงดีกว่า D = 2. ) ผลประเภทนี้เป็นเพราะ Azar, พี่ชาย, คาร์ลินและ Upfal ในกระดาษของพวกเขาสมดุล จัดสรร (มีบางอย่างที่ทำงานก่อนหน้านี้มีผลที่คล้ายกันโดยคาร์พเป็น Luby และเมเยอร์ Auf Der Heide.) ในหลักสูตรของผลลัพธ์เหล่านี้คำถามที่เกิดขึ้นเป็นไปได้ว่าใครจะทำดีกว่าถ้าวางองค์ประกอบออฟไลน์ นั่นคือถ้าคุณมีองค์ประกอบ n และแฮชของพวกเขาล่วงหน้าคุณสามารถวางองค์ประกอบในแต่ละหนึ่งในตัวเลือกของพวกเขาถังและประสบความสำเร็จในการโหลดที่ดีกว่า O (log log n) ที่ได้รับจากการจัดวางลำดับ? คำตอบจะออกมาเป็นใช่ ตำแหน่งที่ดีที่สุดเท่านั้นที่มีโหลดสูงสุดอย่างต่อเนื่อง วิธีการที่จะคิดว่านี้ก็คือจะบอกว่าถ้าเราวางองค์ประกอบตามลำดับ แต่ยังคงมีอำนาจที่จะย้ายพวกเขาในภายหลังตราบใดที่แต่ละองค์ประกอบสิ้นสุดขึ้นที่หนึ่งในตัวเลือกถังของเราจะได้รับลงไปโหลดสูงสุดอย่างต่อเนื่อง. ความคิดของคร่ำเครียดนกกาเหว่าก็คือว่าการเคลื่อนไหวดังกล่าวสามารถทำได้จริงออนไลน์ค่อนข้างมีประสิทธิภาพ คร่ำเครียดนกกาเหว่าเป็นยิ่งปรนัย hashing ย้ายบวกและปรากฏมีประสิทธิภาพมาก ขอให้เราพิจารณากรณีที่รุนแรง, การวิเคราะห์ในต้นฉบับนกกาเหว่ากระดาษ Hashing โดย Pagh และ Rodler (ถ้าคำอธิบายของฉันเป็นที่น่าพอใจมีคำอธิบายที่ดีอยู่แล้วในวิกิพีเดีย) ถังแต่ละคนสามารถมีเพียง 1 รายการและเราจะมี n ถังแยกออกเป็นสอง subtables ขนาด n / 2 แต่ละองค์ประกอบมีหนึ่งทางเลือกของถังในแต่ละ subtable ที่เลือกที่จะได้รับจากฟังก์ชั่นที่เป็นอิสระ แต่ละองค์ประกอบ hashed อยู่ที่หนึ่งในสองทางเลือกของ การค้นหาจึงมักจะต้องใช้เวลามากที่สุดสองเข้าถึงในตารางแฮช. สิ่งที่ต้องทำอย่างไรในการแทรก - สิ่งที่ถ้าช่องว่างทั้งสองรายการจะเต็มแล้ว เมื่อเราใส่รายการใหม่ที่เราใส่ไว้ใน subtable แรก หากรายการอื่นที่มีอยู่แล้วเราเตะมันออกมาและทำให้มันย้ายไป subtable สอง หากรายการอื่นที่มีอยู่แล้วเราเตะมันออกมาและทำให้มันย้ายกลับไปที่ตารางแรกและอื่น ๆ นี่คือที่ชื่อคร่ำเครียดนกกาเหว่ามาจาก; เป็นบทความวิกิพีเดียบอกว่าชื่อที่เกิดขึ้นจากพฤติกรรมของบางสายพันธุ์ของนกกาเหว่าที่แม่นกดันไข่ออกจากรังของนกอื่นที่จะวางของเธอเอง. Pagh และ Rodler พิสูจน์ว่าถ้าจำนวนขององค์ประกอบแทรกเป็นที่มากที่สุด (1 / 2 - เอปไซลอน) n สำหรับบาง Epsilon คงที่แล้วกระบวนการนี้เสร็จสิ้นในระยะเวลาที่คาดว่าจะคงที่! ในคำอื่น ๆ หนึ่งสามารถบรรลุใช้หน่วยความจำได้มากถึงร้อยละ 50 ของกำลังการผลิตที่มีเวลาการค้นหาอย่างต่อเนื่องและเวลารับประกันแทรกเฉลี่ยคงที่. สายพันธุ์ต่อไปอย่างมีนัยสำคัญปรับปรุงการใช้หน่วยความจำที่สามารถทำได้ โดยเฉพาะช่วยให้มากกว่าสองทางเลือกของสถานที่ตั้งช่วย (ทางเลือกมากขึ้นในการที่จะไป) เช่นเดียวกับที่มีมากกว่าหนึ่งรายการต่อถัง (ทางเลือกมากขึ้นของสิ่งที่จะย้าย) ใช้หน่วยความจำมากกว่าร้อยละ 90 เป็นไปได้ในทางปฏิบัติได้อย่างง่ายดาย กระดาษนี้และหนึ่งนี้มีข้อมูลเพิ่มเติม. ที่สรุปพื้นหลังทางทฤษฎีและหวังว่าจะกล่อมคุณว่าความคิดของคร่ำเครียดนกกาเหว่าเป็นดีหนึ่ง ในโพสต์ถัดไปเราจะดูที่ว่าทำไมคุณอาจต้องการที่จะใช้คร่ำเครียดนกกาเหว่าในฮาร์ดแวร์และสิ่งที่อยู่ในนั้นอุปสรรค
หนึ่งสายที่ผ่านมาของการวิจัยที่ฉันได้รับความสุขจริงๆคือการทำงานในสายพันธุ์นกกาเหว่าคร่ำเครียด ปัจจุบันจบการศึกษานักเรียนของฉันอดัม Kirsch และฉันกำลังทำงานในการแก้ปัญหาการส่งคำถามของวิธีการออกแบบสายพันธุ์คร่ำเครียดนกกาเหว่าที่มีการปฏิบัติมากขึ้นในการตั้งค่าของการใช้ฮาร์ดแวร์เช่นสำหรับเราเตอร์ ดังนั้นนี่ทำให้ผมมีข้ออ้างที่จะเขียนเกี่ยวกับคร่ำเครียดนกกาเหว่าอธิบายปัญหาที่เราเห็นในนำมาใช้ในทางปฏิบัติและอธิบายคำถามทางทฤษฎีและปฏิบัติที่น่าสนใจที่มีผล ฉันจะทำมากกว่านี้ชุดของการโพสต์. ในการเริ่มต้นให้เราจำพื้นฐานของอำนาจของสองทางเลือกหรือคร่ำเครียดแบบปรนัย ในการตั้งค่ามาตรฐานที่เรากำลัง hashing องค์ประกอบ n ลงในตารางแฮชกับถัง n ปกติเราจะสับแต่ละรายการหนึ่งครั้งเพื่อตรวจสอบถังของตน นี้จะช่วยให้โหลดสูงสุดหรือจำนวนที่ใหญ่ที่สุดขององค์ประกอบในถังใด ๆ เกี่ยวกับการล็อกของ n / log log n (ทุกผลที่ฉันรัฐถือมีโอกาสสูงดังนั้นฉันจะหลีกเลี่ยงการทำซ้ำวลี.) สมมติว่าเราใช้แทนสองฟังก์ชั่นให้สองทางเลือกของสถานที่สำหรับแต่ละองค์ประกอบ องค์ประกอบที่มีอยู่ตามลำดับในการโหลดน้อยที่สุดของสองถังของพวกเขา เมื่อเราทำค้นหาตอนนี้เราจะต้องดูในสถานที่สองของรายการ ในการกลับไปโหลดสูงสุดในขณะนี้ตกอยู่กับเกี่ยวกับการล็อกล็อก n / log 2 - เราได้มีการบันทึกการพิเศษในการมี! (ด้วยการพัฒนา> 2 ตัวเลือกโหลดสูงสุดจะบันทึก log n / ล็อกงเพียงปัจจัยคงดีกว่า D = 2. ) ผลประเภทนี้เป็นเพราะ Azar, พี่ชาย, คาร์ลินและ Upfal ในกระดาษของพวกเขาสมดุล จัดสรร (มีบางอย่างที่ทำงานก่อนหน้านี้มีผลที่คล้ายกันโดยคาร์พเป็น Luby และเมเยอร์ Auf Der Heide.) ในหลักสูตรของผลลัพธ์เหล่านี้คำถามที่เกิดขึ้นเป็นไปได้ว่าใครจะทำดีกว่าถ้าวางองค์ประกอบออฟไลน์ นั่นคือถ้าคุณมีองค์ประกอบ n และแฮชของพวกเขาล่วงหน้าคุณสามารถวางองค์ประกอบในแต่ละหนึ่งในตัวเลือกของพวกเขาถังและประสบความสำเร็จในการโหลดที่ดีกว่า O (log log n) ที่ได้รับจากการจัดวางลำดับ? คำตอบจะออกมาเป็นใช่ ตำแหน่งที่ดีที่สุดเท่านั้นที่มีโหลดสูงสุดอย่างต่อเนื่อง วิธีการที่จะคิดว่านี้ก็คือจะบอกว่าถ้าเราวางองค์ประกอบตามลำดับ แต่ยังคงมีอำนาจที่จะย้ายพวกเขาในภายหลังตราบใดที่แต่ละองค์ประกอบสิ้นสุดขึ้นที่หนึ่งในตัวเลือกถังของเราจะได้รับลงไปโหลดสูงสุดอย่างต่อเนื่อง. ความคิดของคร่ำเครียดนกกาเหว่าก็คือว่าการเคลื่อนไหวดังกล่าวสามารถทำได้จริงออนไลน์ค่อนข้างมีประสิทธิภาพ คร่ำเครียดนกกาเหว่าเป็นยิ่งปรนัย hashing ย้ายบวกและปรากฏมีประสิทธิภาพมาก ขอให้เราพิจารณากรณีที่รุนแรง, การวิเคราะห์ในต้นฉบับนกกาเหว่ากระดาษ Hashing โดย Pagh และ Rodler (ถ้าคำอธิบายของฉันเป็นที่น่าพอใจมีคำอธิบายที่ดีอยู่แล้วในวิกิพีเดีย) ถังแต่ละคนสามารถมีเพียง 1 รายการและเราจะมี n ถังแยกออกเป็นสอง subtables ขนาด n / 2 แต่ละองค์ประกอบมีหนึ่งทางเลือกของถังในแต่ละ subtable ที่เลือกที่จะได้รับจากฟังก์ชั่นที่เป็นอิสระ แต่ละองค์ประกอบ hashed อยู่ที่หนึ่งในสองทางเลือกของ การค้นหาจึงมักจะต้องใช้เวลามากที่สุดสองเข้าถึงในตารางแฮช. สิ่งที่ต้องทำอย่างไรในการแทรก - สิ่งที่ถ้าช่องว่างทั้งสองรายการจะเต็มแล้ว เมื่อเราใส่รายการใหม่ที่เราใส่ไว้ใน subtable แรก หากรายการอื่นที่มีอยู่แล้วเราเตะมันออกมาและทำให้มันย้ายไป subtable สอง หากรายการอื่นที่มีอยู่แล้วเราเตะมันออกมาและทำให้มันย้ายกลับไปที่ตารางแรกและอื่น ๆ นี่คือที่ชื่อคร่ำเครียดนกกาเหว่ามาจาก; เป็นบทความวิกิพีเดียบอกว่าชื่อที่เกิดขึ้นจากพฤติกรรมของบางสายพันธุ์ของนกกาเหว่าที่แม่นกดันไข่ออกจากรังของนกอื่นที่จะวางของเธอเอง. Pagh และ Rodler พิสูจน์ว่าถ้าจำนวนขององค์ประกอบแทรกเป็นที่มากที่สุด (1 / 2 - เอปไซลอน) n สำหรับบาง Epsilon คงที่แล้วกระบวนการนี้เสร็จสิ้นในระยะเวลาที่คาดว่าจะคงที่! ในคำอื่น ๆ หนึ่งสามารถบรรลุใช้หน่วยความจำได้มากถึงร้อยละ 50 ของกำลังการผลิตที่มีเวลาการค้นหาอย่างต่อเนื่องและเวลารับประกันแทรกเฉลี่ยคงที่. สายพันธุ์ต่อไปอย่างมีนัยสำคัญปรับปรุงการใช้หน่วยความจำที่สามารถทำได้ โดยเฉพาะช่วยให้มากกว่าสองทางเลือกของสถานที่ตั้งช่วย (ทางเลือกมากขึ้นในการที่จะไป) เช่นเดียวกับที่มีมากกว่าหนึ่งรายการต่อถัง (ทางเลือกมากขึ้นของสิ่งที่จะย้าย) ใช้หน่วยความจำมากกว่าร้อยละ 90 เป็นไปได้ในทางปฏิบัติได้อย่างง่ายดาย กระดาษนี้และหนึ่งนี้มีข้อมูลเพิ่มเติม. ที่สรุปพื้นหลังทางทฤษฎีและหวังว่าจะกล่อมคุณว่าความคิดของคร่ำเครียดนกกาเหว่าเป็นดีหนึ่ง ในโพสต์ถัดไปเราจะดูที่ว่าทำไมคุณอาจต้องการที่จะใช้คร่ำเครียดนกกาเหว่าในฮาร์ดแวร์และสิ่งที่อยู่ในนั้นอุปสรรค
การแปล กรุณารอสักครู่..
นกกาเหว่าแฮช ทฤษฎีและการปฏิบัติ : ส่วนที่ 1
1 บรรทัดล่าสุดของการวิจัยฉันได้ถูกกับงานบริการเป็นคัคคูพันธุ์ ปัจจุบัน ลูกศิษย์บัณฑิตอดัม Kirsch และฉันกำลังเสนอการแก้ปัญหาคำถามของวิธีการออกแบบคัคคูพันธุ์ hashing ที่ปฏิบัติมากขึ้นในการตั้งค่าของการสร้างฮาร์ดแวร์เช่นเราเตอร์ .นี่ให้ฉันแก้ตัวที่จะเขียนเกี่ยวกับนกคัคคูแฮช อธิบายปัญหาที่เราเห็นในการใช้พวกเขาในการปฏิบัติ และการอธิบายที่น่าสนใจทางทฤษฎีและปัญหาในทางปฏิบัติที่ผล ผมจะทำผ่านชุดของการโพสต์
เริ่มต้น ให้เรานึกถึงพื้นฐานของพลังงาน 2 ทางเลือก หรือแบบแฮชชิ่ง . ในการตั้งค่ามาตรฐานเรามีบริการของในตารางแฮชด้วยถัง โดยปกติ เราจะสับแต่ละรายการหนึ่งครั้งเพื่อตรวจสอบถัง ; นี้จะช่วยให้ โหลดสูงสุด หรือหมายเลขที่ใหญ่ที่สุดขององค์ประกอบในถังประมาณเข้าสู่ระบบเข้าสู่ระบบเข้าสู่ระบบ / N . ( ผลลัพธ์ทั้งหมดที่ฉันรัฐถือกับความน่าจะเป็นสูง ดังนั้น ผมจะหลีกเลี่ยงการทำซ้ำวลี ) สมมติว่าเราใช้สองกัญชาฟังก์ชันให้เลือกสองสถานที่สำหรับแต่ละองค์ประกอบ มีองค์ประกอบที่โดดเด่นอยู่ในอย่างน้อยโหลดสองถังของพวกเขา เมื่อเราทำการค้นหา เราจะต้องมองในสองสถานที่ สำหรับรายการ ในทางกลับกัน , โหลดสูงสุด ตอนนี้ตกประมาณเข้าสู่ระบบเข้าสู่ระบบเข้าสู่ระบบ n / 2 . . . เราได้มีบันทึกพิเศษในนั้น ( D > 2 ตัวเลือก โหลดสูงสุดจะเข้าสู่ระบบเข้าสู่ระบบเข้าสู่ระบบ n / Dแค่ปัจจัยคงที่ดีกว่า D = 2 ) ผลของชนิดนี้เนื่องจากลาซาร์ โบรเดอร์ คาร์ลิน , , , และ upfal ในกระดาษที่สมดุลการจัดสรรของพวกเขา ( มี ก่อนหน้านี้ทำงานกับผลที่คล้ายกันโดย คาร์พ ลูบี้ และเมเยอร์ใน der Heide )
ในหลักสูตรของผลลัพธ์เหล่านี้ คำถามเกิดขึ้นว่าเราทำได้ดีกว่านี้ ถ้าวางองค์ประกอบครับ นั่นคือถ้าคุณมีทั้งหมดของพวกเขาและ hashes ในล่วงหน้า คุณสามารถวางองค์ประกอบในแต่ละทางเลือกหนึ่งถังของพวกเขาและบรรลุโหลดดีกว่า O ( log log n ) ได้ โดยการจัดวางลำดับ ? คำตอบจะออกครับ ตำแหน่งที่ดีที่สุดมีเพียงโหลดสูงสุดคงที่ วิธีคิดก็คือว่า ถ้าเราวางองค์ประกอบตามลําดับ ,แต่รักษาอำนาจที่จะย้ายพวกเขาในภายหลัง ตราบใดที่แต่ละองค์ประกอบจะสิ้นสุดในหนึ่งในตัวเลือกถังของมัน เราสามารถไปโหลดสูงสุดคงที่
ความคิดของนกกาเหว่า hashing คือ การเคลื่อนไหวดังกล่าวจริงสามารถทำได้ออนไลน์ค่อนข้างมีประสิทธิภาพ นกกาเหว่า hashing เป็นหลักแบบแฮชชิงบวกย้ายและดูเหมือนว่ามีประสิทธิภาพมาก ให้เราพิจารณากรณีสุดโต่งวิเคราะห์ข้อมูลในกระดาษและบริการเดิมเป็นบ้า pagh rodler . ( ถ้ารายละเอียดของฉันเป็นที่น่าพอใจ มีคำอธิบายที่ดีอยู่แล้วในวิกิพีเดีย ) แต่ละถังสามารถบรรจุเพียง 1 รายการ และเราจะมี N ถังแยกเป็นสอง subtables ขนาด n / 2 แต่ละองค์ประกอบมีหนึ่งทางเลือกของถังในแต่ละ subtable ที่ตัวเลือกให้โดยหน้าที่สับที่เป็นอิสระแต่ละองค์ประกอบ hashed อยู่หนึ่งในสองตัวเลือก การค้นหาที่ใช้มากที่สุด จึงมักจะต้องใช้สองในตารางแฮช
ทำไงดี อย่างไรก็ตามเมื่อมีการแทรก . . . ถ้าทั้งคู่เป็นสำหรับรายการจะเต็มแล้ว ? เมื่อเราแทรกรายการใหม่ที่เราใส่ไว้ใน subtable ก่อน ถ้ารายการอื่นก็มี เราเตะมันออกไป และให้ย้ายไป subtable วินาทีถ้ารายการอื่นก็มี เราเตะมันออก แล้วให้มันกลับไปที่โต๊ะก่อน และอื่น ๆ นี่คือที่ชื่อคัคคู hashing มาจาก ตามที่วิกิพีเดียบทความบอกว่า
ชื่อมาจากพฤติกรรมของบางชนิดของนกคัคคู ที่แม่นกดันไข่จากรังของนกอื่นที่จะวางของเธอเอง
.และ pagh rodler พิสูจน์ว่าถ้าจำนวนขององค์ประกอบแทรกอยู่มากที่สุด ( 1 / 2 - เอปไซลอน ) n บางคงที่เอปไซลอนก็เสร็จสิ้นกระบวนการนี้อย่างต่อเนื่องคาดว่าในเวลา ! ในคำอื่น ๆหนึ่งสามารถบรรลุการใช้หน่วยความจำได้ถึง 50 เปอร์เซ็นต์ ของความจุ พร้อมรับประกันการค้นหาคงที่และเวลาแทรก
เฉลี่ยคงที่ตัวแปรเพิ่มเติมปรับปรุงหน่วยความจำการใช้ประโยชน์ที่ได้ โดยเฉพาะ ให้มากกว่าสองตัวเลือกของสถานที่ช่วย ( ตัวเลือกเพิ่มเติมที่จะไป ) เนื่องจากมีมากกว่าหนึ่งรายการต่อถัง ( ทางเลือกที่มากขึ้นของสิ่งที่เคลื่อนไหว ) หน่วยความจำการใช้กว่า 90 เปอร์เซ็นต์เป็นไปได้ง่ายในการปฏิบัติ กระดาษแผ่นนี้ และหนึ่งในนี้มีข้อมูลเพิ่มเติม
ที่สรุปทฤษฎีพื้นฐาน และหวังว่า convinces คุณว่า ความคิดของนกกาเหว่า hashing เป็นดีหนึ่ง ในการโพสต์ต่อไป เราต้องดูที่เหตุผลที่คุณอาจต้องการที่จะใช้บริการบริการฮาร์ดแวร์และอุปสรรคอะไรอยู่ในนั้น
1 บรรทัดล่าสุดของการวิจัยฉันได้ถูกกับงานบริการเป็นคัคคูพันธุ์ ปัจจุบัน ลูกศิษย์บัณฑิตอดัม Kirsch และฉันกำลังเสนอการแก้ปัญหาคำถามของวิธีการออกแบบคัคคูพันธุ์ hashing ที่ปฏิบัติมากขึ้นในการตั้งค่าของการสร้างฮาร์ดแวร์เช่นเราเตอร์ .นี่ให้ฉันแก้ตัวที่จะเขียนเกี่ยวกับนกคัคคูแฮช อธิบายปัญหาที่เราเห็นในการใช้พวกเขาในการปฏิบัติ และการอธิบายที่น่าสนใจทางทฤษฎีและปัญหาในทางปฏิบัติที่ผล ผมจะทำผ่านชุดของการโพสต์
เริ่มต้น ให้เรานึกถึงพื้นฐานของพลังงาน 2 ทางเลือก หรือแบบแฮชชิ่ง . ในการตั้งค่ามาตรฐานเรามีบริการของในตารางแฮชด้วยถัง โดยปกติ เราจะสับแต่ละรายการหนึ่งครั้งเพื่อตรวจสอบถัง ; นี้จะช่วยให้ โหลดสูงสุด หรือหมายเลขที่ใหญ่ที่สุดขององค์ประกอบในถังประมาณเข้าสู่ระบบเข้าสู่ระบบเข้าสู่ระบบ / N . ( ผลลัพธ์ทั้งหมดที่ฉันรัฐถือกับความน่าจะเป็นสูง ดังนั้น ผมจะหลีกเลี่ยงการทำซ้ำวลี ) สมมติว่าเราใช้สองกัญชาฟังก์ชันให้เลือกสองสถานที่สำหรับแต่ละองค์ประกอบ มีองค์ประกอบที่โดดเด่นอยู่ในอย่างน้อยโหลดสองถังของพวกเขา เมื่อเราทำการค้นหา เราจะต้องมองในสองสถานที่ สำหรับรายการ ในทางกลับกัน , โหลดสูงสุด ตอนนี้ตกประมาณเข้าสู่ระบบเข้าสู่ระบบเข้าสู่ระบบ n / 2 . . . เราได้มีบันทึกพิเศษในนั้น ( D > 2 ตัวเลือก โหลดสูงสุดจะเข้าสู่ระบบเข้าสู่ระบบเข้าสู่ระบบ n / Dแค่ปัจจัยคงที่ดีกว่า D = 2 ) ผลของชนิดนี้เนื่องจากลาซาร์ โบรเดอร์ คาร์ลิน , , , และ upfal ในกระดาษที่สมดุลการจัดสรรของพวกเขา ( มี ก่อนหน้านี้ทำงานกับผลที่คล้ายกันโดย คาร์พ ลูบี้ และเมเยอร์ใน der Heide )
ในหลักสูตรของผลลัพธ์เหล่านี้ คำถามเกิดขึ้นว่าเราทำได้ดีกว่านี้ ถ้าวางองค์ประกอบครับ นั่นคือถ้าคุณมีทั้งหมดของพวกเขาและ hashes ในล่วงหน้า คุณสามารถวางองค์ประกอบในแต่ละทางเลือกหนึ่งถังของพวกเขาและบรรลุโหลดดีกว่า O ( log log n ) ได้ โดยการจัดวางลำดับ ? คำตอบจะออกครับ ตำแหน่งที่ดีที่สุดมีเพียงโหลดสูงสุดคงที่ วิธีคิดก็คือว่า ถ้าเราวางองค์ประกอบตามลําดับ ,แต่รักษาอำนาจที่จะย้ายพวกเขาในภายหลัง ตราบใดที่แต่ละองค์ประกอบจะสิ้นสุดในหนึ่งในตัวเลือกถังของมัน เราสามารถไปโหลดสูงสุดคงที่
ความคิดของนกกาเหว่า hashing คือ การเคลื่อนไหวดังกล่าวจริงสามารถทำได้ออนไลน์ค่อนข้างมีประสิทธิภาพ นกกาเหว่า hashing เป็นหลักแบบแฮชชิงบวกย้ายและดูเหมือนว่ามีประสิทธิภาพมาก ให้เราพิจารณากรณีสุดโต่งวิเคราะห์ข้อมูลในกระดาษและบริการเดิมเป็นบ้า pagh rodler . ( ถ้ารายละเอียดของฉันเป็นที่น่าพอใจ มีคำอธิบายที่ดีอยู่แล้วในวิกิพีเดีย ) แต่ละถังสามารถบรรจุเพียง 1 รายการ และเราจะมี N ถังแยกเป็นสอง subtables ขนาด n / 2 แต่ละองค์ประกอบมีหนึ่งทางเลือกของถังในแต่ละ subtable ที่ตัวเลือกให้โดยหน้าที่สับที่เป็นอิสระแต่ละองค์ประกอบ hashed อยู่หนึ่งในสองตัวเลือก การค้นหาที่ใช้มากที่สุด จึงมักจะต้องใช้สองในตารางแฮช
ทำไงดี อย่างไรก็ตามเมื่อมีการแทรก . . . ถ้าทั้งคู่เป็นสำหรับรายการจะเต็มแล้ว ? เมื่อเราแทรกรายการใหม่ที่เราใส่ไว้ใน subtable ก่อน ถ้ารายการอื่นก็มี เราเตะมันออกไป และให้ย้ายไป subtable วินาทีถ้ารายการอื่นก็มี เราเตะมันออก แล้วให้มันกลับไปที่โต๊ะก่อน และอื่น ๆ นี่คือที่ชื่อคัคคู hashing มาจาก ตามที่วิกิพีเดียบทความบอกว่า
ชื่อมาจากพฤติกรรมของบางชนิดของนกคัคคู ที่แม่นกดันไข่จากรังของนกอื่นที่จะวางของเธอเอง
.และ pagh rodler พิสูจน์ว่าถ้าจำนวนขององค์ประกอบแทรกอยู่มากที่สุด ( 1 / 2 - เอปไซลอน ) n บางคงที่เอปไซลอนก็เสร็จสิ้นกระบวนการนี้อย่างต่อเนื่องคาดว่าในเวลา ! ในคำอื่น ๆหนึ่งสามารถบรรลุการใช้หน่วยความจำได้ถึง 50 เปอร์เซ็นต์ ของความจุ พร้อมรับประกันการค้นหาคงที่และเวลาแทรก
เฉลี่ยคงที่ตัวแปรเพิ่มเติมปรับปรุงหน่วยความจำการใช้ประโยชน์ที่ได้ โดยเฉพาะ ให้มากกว่าสองตัวเลือกของสถานที่ช่วย ( ตัวเลือกเพิ่มเติมที่จะไป ) เนื่องจากมีมากกว่าหนึ่งรายการต่อถัง ( ทางเลือกที่มากขึ้นของสิ่งที่เคลื่อนไหว ) หน่วยความจำการใช้กว่า 90 เปอร์เซ็นต์เป็นไปได้ง่ายในการปฏิบัติ กระดาษแผ่นนี้ และหนึ่งในนี้มีข้อมูลเพิ่มเติม
ที่สรุปทฤษฎีพื้นฐาน และหวังว่า convinces คุณว่า ความคิดของนกกาเหว่า hashing เป็นดีหนึ่ง ในการโพสต์ต่อไป เราต้องดูที่เหตุผลที่คุณอาจต้องการที่จะใช้บริการบริการฮาร์ดแวร์และอุปสรรคอะไรอยู่ในนั้น
การแปล กรุณารอสักครู่..
ภาษาอื่น ๆ
การสนับสนุนเครื่องมือแปลภาษา: กรีก, กันนาดา, กาลิเชียน, คลิงออน, คอร์สิกา, คาซัค, คาตาลัน, คินยารวันดา, คีร์กิซ, คุชราต, จอร์เจีย, จีน, จีนดั้งเดิม, ชวา, ชิเชวา, ซามัว, ซีบัวโน, ซุนดา, ซูลู, ญี่ปุ่น, ดัตช์, ตรวจหาภาษา, ตุรกี, ทมิฬ, ทาจิก, ทาทาร์, นอร์เวย์, บอสเนีย, บัลแกเรีย, บาสก์, ปัญจาป, ฝรั่งเศส, พาชตู, ฟริเชียน, ฟินแลนด์, ฟิลิปปินส์, ภาษาอินโดนีเซี, มองโกเลีย, มัลทีส, มาซีโดเนีย, มาราฐี, มาลากาซี, มาลายาลัม, มาเลย์, ม้ง, ยิดดิช, ยูเครน, รัสเซีย, ละติน, ลักเซมเบิร์ก, ลัตเวีย, ลาว, ลิทัวเนีย, สวาฮิลี, สวีเดน, สิงหล, สินธี, สเปน, สโลวัก, สโลวีเนีย, อังกฤษ, อัมฮาริก, อาร์เซอร์ไบจัน, อาร์เมเนีย, อาหรับ, อิกโบ, อิตาลี, อุยกูร์, อุสเบกิสถาน, อูรดู, ฮังการี, ฮัวซา, ฮาวาย, ฮินดี, ฮีบรู, เกลิกสกอต, เกาหลี, เขมร, เคิร์ด, เช็ก, เซอร์เบียน, เซโซโท, เดนมาร์ก, เตลูกู, เติร์กเมน, เนปาล, เบงกอล, เบลารุส, เปอร์เซีย, เมารี, เมียนมา (พม่า), เยอรมัน, เวลส์, เวียดนาม, เอสเปอแรนโต, เอสโทเนีย, เฮติครีโอล, แอฟริกา, แอลเบเนีย, โคซา, โครเอเชีย, โชนา, โซมาลี, โปรตุเกส, โปแลนด์, โยรูบา, โรมาเนีย, โอเดีย (โอริยา), ไทย, ไอซ์แลนด์, ไอร์แลนด์, การแปลภาษา.
- ภายในอาทิตย์หน้าจะมีการจัดอบรมสำหรับพนัก
- ตลกดี
- remedyRead more at http://www.beliefnet.
- ในฤดูหนาว
- Nitrate pollution of groundwater and sur
- History Fact Finding
- perfect
- Indeed, the very idea of globalization a
- perform
- ฉันชอบที่จะลงมือทำนั่งคิด
- cry out
- Tiring, I've been practicing and doing m
- Why can not call
- In regard to the safety of sailing vesse
- เตย
- ฉันจะเก็บไว้ในความทรงจำที่ดี
- ไม่ใช่จบ แต่ยังไม่เริ่มต้นสิ้นสุดวันของเ
- เทพธิดา
- I am going to spend there two weeks.I am
- I have something to tell you. Now my pho
- แต่กรณีในการรักษาแสดงออกมาว่าวัคซีนของไข
- Soaring
- 往返
- Even my parents still ignoring me
