WO2016122652A1

WO2016122652A1 - Cuckoo hash table

Info

Publication number: WO2016122652A1
Application number: PCT/US2015/013946
Authority: WO
Inventors: William Henry KASZMAUL
Original assignee: Hewlett Packard Enterprise Development Lp
Priority date: 2015-01-30
Filing date: 2015-01-30
Publication date: 2016-08-04

Abstract

Example implementations relate to cuckoo hash tables. For example, a system for cuckoo hashing can include a hash table engine to maintain a hash table including a slot, a thread receipt engine to receive a first thread including a first insertion key, and a second thread including a second insertion key. Further, the cuckoo hashing system can include a claim flag engine to insert a claim flag in the slot by the first thread, where the claim flag indicates to the second thread that the slot is reserved by the first thread for the first insertion key.

Description

CUCKOO HASH TABLE

Background

[0001] Hashing can distribute entries, such as keys or values, across an array of buckets. A hash function can be used to map digital data of an arbitrary size to digital data of a fixed size. Given a key, an index may suggest where a particular entry may be located within a hash table, which can be used for data lookup.

Brief Description of the Drawings

[0002] Figure 1 illustrates a diagram of an example of a system for a cuckoo hash table according to the present disclosure;

[0003] Figure 2 illustrates a diagram of an example computing device according to the present disclosure;

[0004] Figure 3 illustrates an example of a cuckoo hash table, according to the present disclosure;

[0005] Figure 4 illustrates an example of a cuckoo hash table, according to the present disclosure;

[0006] Figure 5 illustrates an example of a method for a cuckoo hash table, accordingly to the present disclosure;

[0007] Figure 6 illustrates flow diagram of an example method a cuckoo hash table, according to the present disclosure; and

[0008] Figure 7 illustrates a flow diagram of an example computing device for a cuckoo hash table, according to the present disclosure. Detailed Description

[0009] Cuckoo hashing is a hash-table setup that includes constant-time reads. Each hash function maps to a bin, each of which can contain slots, each of which can contain one key. A key is a digital record, such as a value or key-value pair, that is a unique identifier. Cuckoo hashing seeks to resolve hash collisions of values of hash functions in a table and can include a worst-case constant lookup time. A collision, as used herein, refers to a conflict among threads, including when multiple writers (e.g., threads) attempt to write to a same slot in a same bin in a same commit cycle. A collision can result in an abort. An abort is a termination of a particular transaction being run by a thread (e.g., writing to a slot in a bin).

[0010] A transaction includes either a single or a plurality of operations, such as insertions, deletions, overwrites, and reads. In a serializable hash table, each transaction can behave as though it occurred in a fixed moment of time. For example, a thread can plan a transaction, such as by user application. In some instances, the thread can enter a commit phase after the transaction is planned from start to finish. The commit phase can include the thread locking the slot it intends to change (e.g., for inserting a key) in the hash table. During the commit phase, in some examples, the thread can confirm that none of the items read during the transaction have changed in value. That is, the slots can be read during the planning period of the transaction using version-identification counters, which may be changed when a slot is changed in value. The thread can apply the transaction and undo the locks. If at any point during the operation the transaction fails, the entire transaction may be aborted.

[0011] Cuckoo hashing can include a hash-table setup with two (or more) hash functions. To insert a key (e.g., record), such as key x, a thread may attempt to insert key x into one of the two bins to which it is hashed. If neither bin includes an empty slot (e.g., free slot, space), the thread may resort to a kick-out. That is, one of the keys (e.g., record) in one of the two bins is selected and the key is kicked-out of the slot. The thread may insert key x in the former place of the key. The kicked-out key can then be inserted into another bin to which it is hashed. This process may be iterative, performing a chain of random walk kick-outs to find placements for kicked-out keys. [0012] Although a single key insertion in a random walk kick-out may lead to an arbitrary number of kick-outs, at the end of the chain (e.g., sequence) every key (e.g., record) is in one of the two (or more) bins to which it is hashed. Cuckoo hashing includes reads that run in constant time because each key has a fixed number of bins to which it may possibly be hashed. The kick-outs may include collisions and cause aborts. The aborts may negatively affect work performance due to wasted time expenditure and inefficiency.

[0013] Using a serializable multi-threaded cuckoo hashing scheme, collisions may occur and lead to aborts. Collisions (e.g., conflicts) among hash values may increase when members of a large set are mapped to a short bit string. Additionally, modifying the same data structure with many threads at once may increase collisions (e.g., conflicts) among threads, which may lead to transaction aborts and affect performance.

[0014] Some cuckoo hash tables use a large hash table to limit conflicts between threads. However, such cuckoo hash tables may add additional expenses to systems implementing them by requiring a greater amount of memory storage space than necessary. Some cuckoo hash tables can use large bins to limit conflicts between threads. However, such cuckoo hash tables may add additional expenses to systems implementing them because large bins (e.g., increased number of slots per bin) can require longer search times as opposed to smaller bins (e.g., decreased number of slots per bin).

[0015] Examples in accordance with the present disclosure can include reducing cuckoo hashing aborts. An example of a cuckoo hashing system can include a hash table including a slot, a first thread including a first insertion key, and a second thread including a second insertion key. Additionally, a cuckoo hashing system can include a claim flag inserted in the slot by the first thread, where the claim flag indicates to the second thread that the slot is reserved by the first thread for the first insertion key.

[0016] Figure 1 illustrates a diagram of an example of a system for reducing cuckoo hash aborts according to the present disclosure. As shown in the example of Figure 1 , the system 100 can include a database 102 accessible by and in

communication with a plurality of engines 104. The engines 104 can include a hash table engine 106, thread receipt engine 108, and claim flag engine 1 10. The system 100 can include additional or fewer engines than illustrated to perform the various functions described herein and embodiments are not limited to the example shown in Figure 1 . The system 100 can include hardware, e.g., in the form of transistor logic and/or application specific integrated circuitry (ASICs), firmware, and software, e.g., in the form of machine readable and executable instructions (program instructions

(programming) stored in a machine readable medium (MRM)) which in cooperation can form a computing device as discussed in connection with Figure 2.

[0017] The plurality of engines can include a combination of hardware and software, e.g., program instructions that are executable by a hardware processor. The program instructions (e.g., computer or machine readable instructions (CRI/MRI)) can include instructions stored on a memory resource and executable by a processing resource to perform a particular function, task and/or action, as discussed further in connection with Figure 2. Each of the plurality of engines at least include hardware that is configured to perform particular functions, tasks and/or actions. For example, the engines shown in Figure 1 can be used to reduce cuckoo hashing aborts.

[0018] The hash table engine 106 can include hardware and/or a combination of hardware and program instructions to maintain a hash table including a slot. As described herein, a hash table refers to a data structure that can map keys to values. The hash table can use a hash function to compute an index into an array of slots, from which a correct value can be found. In some examples, the hash table can be a cuckoo hash-table. As described herein, a cuckoo hash-table refers to a hash-table which implements a cuckoo hashing scheme. A cuckoo hashing scheme, as described herein, refers to a hashing scheme in which a key is inserted into a slot in the cuckoo hash table, and if a collision occurs when inserting the key into the slot in the cuckoo hash table, the conflicting key is "kicked out" of the slot to which the key was inserted. For example, a first key can be inserted into the slot in the cuckoo hash table. If a second key is already in the slot in the cuckoo hash table, the second key can be removed, or kicked-out, of the slot and the first key can be inserted in its place. The second key can then be inserted into a different slot within the cuckoo hash table, as described further herein. Also, as described in relation to Figure 3, the hash table can be a serializable hash table that uses an optimistic concurrency scheme.

[0019] The system 100 can also include a thread receipt engine 108. The thread receipt engine can receive a first thread including a first insertion key, and a second thread including a second insertion key, as described further in relation to Figures 3 and 4. Also, as described further in relation to Figure 3, the thread receipt engine 108 can implement a lock operation by a first thread to lock a slot and commit a first insertion key in the slot.

[0020] Further, the system 100 can include a claim flag engine 1 10. As described in relation to Figures 3 and 4, the claim flag engine 1 10 can insert a claim flag in a slot by a first thread, where the claim flag indicates to a second thread that the slot is reserved by the first thread for insertion of a key by the first thread. For example, the claim flag engine 1 10 can change a value of a bit associated with the slot to indicate to the second thread, and any other thread for that matter, that the slot is reserved for the first thread. However, the claim flag engine 1 10 can also allow read-access of information stored in the slot, to the second thread, and any other thread for that matter. In some examples, the claim flag engine 1 10 can prevent insertion of a second insertion key by a second thread.

[0021] Examples are not limited to the engines shown in Figure 1 and one or more engines described may be combined or may be a sub-engine of another engine. Further, the engines shown may be remote from one another in a distributed computing environment, cloud computing environment, etc.

[0022] Figure 2 illustrates a diagram of an example computing device for reducing cuckoo hashing aborts according to the present disclosure. The computing device 201 can utilize hardware, software (e.g., program instructions that are

executable by a hardware processor), firmware that is executable by a hardware processor, and/or logic to perform a number of functions described herein. The computing device 201 can be any combination of hardware and program instructions configured to share information. The hardware can, for example, include a processing resource 212 and a memory resource 216 (e.g., computer or machine readable medium (CRM/MRM), database, etc.). A processing resource 212, as used herein, can include one or more processors capable of executing instructions stored by the memory resource 216. The processing resource 212 may be implemented in a single device or distributed across multiple devices. The program instructions (e.g., computer or machine readable instructions (CRI/MRI)) can include instructions stored on the memory resource 216 and executable by the processing resource 212 to perform a particular function, task and/or action (e.g. insert a claim flag within a slot.).

[0023] The memory resource 216 can be a non-transitory machine readable medium, including one or more memory components capable of storing instructions that can be executed by a processing resource 212, and may be integrated in a single device or distributed across multiple devices. Further, memory resource 216 may be fully or partially integrated in the same device as processing resource 212 or it may be separate but accessible to that device and processing resource 212. Thus, it is noted that the computing device 201 may be implemented on a participant device, on a server device, on a collection of server devices, and/or a combination of a participant, (e.g., user/consumer endpoint device), and one or more server devices as part of a

distributed computing environment, cloud computing environment, etc.

[0024] The memory resource 216 can be in communication with the processing resource 212 via a communication link (e.g., a path) 214. The communication link 214 can provide a wired and/or wireless connection between the processing resource 212 and the memory resource 216.

[0025] In the example of Figure 2, the memory resource 216 includes a hash table module 218, a thread receipt module 220, and a claim flag module 222. As used herein a module can include program code (e.g., computer executable instructions), hardware, firmware, and/or logic, but includes at least instructions executable by a processing resource, for example, processing resource 212, to perform a particular task, function and/or action. The plurality of modules may be combined or may be sub- modules of other modules. As shown in Figure 2, the hash table module 218, the thread receipt module 220, and the claim flag module 222 can be individual modules located on one memory resource 216. Embodiments are not so limited, however, and a plurality of modules can be located at separate and distinct memory resource locations, for example, in a distributed computing environment, cloud computing environment, etc. [0026] Each of the plurality of modules can include instructions that when executed by the processing resource 212 can function as an engine such as the engines described in connection with Figure 1 . For example, the hash table module 218 can include instructions that when executed by the processing resource 212 can function as the hash table engine 106 shown in Figure 1 . The thread receipt module 220 can include instructions that when executed by the processing resource 212 can function as the thread receipt engine 108 shown in Figure 1 . Additionally, the claim flag module 220 can include instructions that when executed by the processing resource 212 can function as the claim flag engine 1 10 shown in Figure 1 .

[0027] Embodiments are not limited to the example modules shown in Figure 2 and in some cases a number of modules can operate together to function as a particular engine. Further, the engines and/or modules of Figures 1 and 2 can be located in a single system and/or computing device or reside in separate distinct locations in a distributed network, cloud computing, enterprise service environment (e.g., Software as a Service (SaaS) environment), etc.

[0028] Figure 3 illustrates an example of a cuckoo hashing scheme to reduce cuckoo hashing aborts, according to the present disclosure. The scheme illustrated in Figure 3 can be implemented by system 100 and/or computing device 201 , as described in Figures 1 and 2, respectively. As previously discussed, cuckoo hashing can include a hash-table setup with two (or more) hash functions. A thread may attempt to insert a key into one of the two (or more) bins to which it is hashed.

[0029] As illustrated in Figure 3, a cuckoo hash table can include a bin 303 with a plurality of slots 326-1 , 326-2, 326-3, and 326-4 generally referred to as 326. The bin 303 can include a plurality of slots 326. In some examples, the plurality of slots 326 can be finite, in that there can be a limited number of slots 326 in a bin 303. In other words, the bin 303 can include a limited number of slots 326.

[0030] The plurality of slots 326 may include keys (e.g., A, C, D) within the each of the slots 326. Keys, as used herein, are digital records written to a slot 326. The slots 326 may include up to one key associated with each slot 326. That is, the slots and keys may function in a 1 :1 ratio. For example, as illustrated in Figure 3, slot 326-1 can include key A; slot 326-3 can include key C; slot 326-4 can include key D; and slot 326-2 may not include a record, making it an empty slot 324.

[0031] A first thread 330 may wish to insert a first key, x, into the bin 303. The first thread 330 can look for an empty slot 324 before kicking-out a key in a slot 326. In some examples, a kick-out can be arbitrary and/or random, in that a slot 326 can be selected to have a key removed from the slot 326 without a particular order. That is, an empty slot 324 is preferred over a slot occupied by a key (e.g., keys A, C, D illustrated in Figure 1 ). The first thread 330 can identify the empty slot 324 within the bin 330 in which to write the first insertion key, x.

[0032] A second thread 328 may also wish to insert a second key, y, into the bin 330. The second thread 328 can also look for an empty slot 324 before arbitrarily kicking-out a key in a slot 326. The second thread can identify empty slot 324 within the bin in which to write the second key, y.

[0033] A potential collision between the first thread 330 and the second thread 328 is depicted in Figure 3. That is, the first thread 330 and the second thread 328 are in conflict. The first thread 330 and the second thread 328 cannot collectively write both keys, x and y, to the empty slot 324 because each slot 326 may only include one key (e.g., 1 :1 ratio). In other words, only one thread (e.g., first or second thread) may write their respective key (e.g., x, y) within the empty slot 324.

[0034] To prevent collisions between threads, a claim flag 332 can prevent insertion of the second key into the slot 326 by the second thread 328. The claim flag 332 can change a value of a bit associated with the slot 326 to indicate the slot is 326 claimed (e.g., reserved, held) for a particular thread (e.g., first thread with a first key). That is, a claim signifies an intent to edit the slot, but not yet editing the slot.

[0035] The change in the bit does not lock (e.g., spin lock) the slot 326, but merely places a claim (e.g., a "hold") on the slot 326. That is, as opposed to a lock (e.g., spin lock), a claim can permit threads to read the slot. For example, the first thread 330 can insert a claim flag 332 to indicate to the second thread that the empty slot 324 is claimed and may not be empty in a particular period of time. Further, in some instances, a third thread can check whether a third key is present in bin 303. The third thread may still read slot 324 even though the slot is claimed. If a lock were used instead of a claim, the third thread may wait a period of time for slot 324 to be unlocked before the third thread may confirm that the third key is not, in fact, located in bin 324.

[0036] In some examples, the claim flag 332 can allow read-access of

information stored in the slot 326 to the second thread 328. That is, a slot 326 with an inserted claim flag 332 can be read by other threads to see whether a key (e.g., record) is presently recorded. By not restricting read access, claim flags can avoid risk of deadlock between threads.

[0037] The read-access can assist in preventing cuckoo hashing collisions and aborts by allowing different threads to identify reserved slots via the claim flag 332. The different threads do not have to wait, anticipating being able to write their respective key in a slot 326 that is claimed. The different threads can move along the bin 303 to find a different empty slot or resort to kicking-out a key (e.g., A, C, D) in a slot 326. As an example, as illustrated in Figure 3, second thread 328 wishes to insert key, y, into empty slot 324. The claim flag 332 can allow the thread 328 to decide not to try inserting the key into empty slot 324. The second thread 328 can kick key C out of the slot 326-3 and insert key y in its place.

[0038] Though threads can claim an empty slot 324, overwrites and deletes are not competing for the empty slot 324, and thus may not have to wait on the claim. That is, overwrites and deletes may not apply to an empty slot 324. In addition, claims may not be limited in usefulness to two threads. For example, if a third thread with a third key, z, sees the empty slot 324 is claimed, it also need not wait. That is, because there are a plurality of slots 326 within each bin (e.g., 303) assigned to the key being inserted, the third thread may simply insert the third key, z, within a different slot (e.g., a second empty slot). Alternatively, if a different slot (e.g., a second empty slot) is not available, the third thread can resort to a kick-out scheme, thereby, avoiding collisions (e.g., conflicts) between threads.

[0039] In some examples, a thread may claim a slot that is not empty for a kick- out chain. Although read access is not restricted by a claim (e.g., claim flag), other threads may still access the claimed slot, which can avoid potential aborts and/or deadlocks. That is, in some instances, a first thread may claim a slot that is not empty for an overwrite action or delete action. For example, a second thread, seeking to perform an overwrite action or delete action in a particular slot containing a key, may decide to abort if the slot is already claimed by a first thread. The slot claimed by a first thread for an overwrite action or delete action can avoid being used in a kick-out chain by an insertion action, thereby avoiding potential aborts. For instance, an insertion action can perform kick-out chains as system transactions (e.g., prior to the commit phase of the transaction), and the first thread can claim the resulting empty slot.

[0040] Additionally, subsequent to insertion of a claim flag, a lock operation (e.g., a spin lock) can be implemented by the first thread to lock the slot and commit the first insertion key. For example the first thread can claim a slot 326 for a period of time, and once the thread transaction reaches a commit phase (e.g., confirmation), the slot 326 can be locked. That is, claiming and locking are two different actions that may work together when a thread inserts a key into the slot 326.

[0041] In some examples, the cuckoo hashing scheme can include a version- identification counter, which may work in a manner similar to counting a number of times the slot is changed and is unaffected by the claim flag. In such examples, the system 100 illustrated in Figure 1 , and the computing device 201 illustrated in Figure 2, can include a version identification counter engine and a version identifier counter module, respectively, to count the number of times a slot is changed and/or unaffected by a claim flag. The version-identification counter, can in turn, be used to facilitate a concurrency scheme. That is, in a serializable optimistic concurrency scheme using a version-identification number, using claim flags can reduce aborts of transactions. For example, a thread can check at a commit phase whether the version-identification counter associated with slots read during the transaction have or have not changed. If any of the version-identification counters have changed, the thread may abort the entire transaction. In contrast, with a lock (e.g., spin lock), a claim may not result in changing a version-identification counter associated with a slot, thereby avoiding potential aborts.

[0042] Figure 4 illustrates an example of a cuckoo hashing scheme to reduce cuckoo hashing aborts, according to the present disclosure. The scheme illustrated in Figure 4 can be implemented by system 100 and/or computing device 201 as described in Figures 1 and 2, respectively. A random walk is a scheme for randomly selecting a key to kick-out of a slot. Long kick-out chains can lead to increased aborts due to a thread editing many keys (e.g., records) in a transaction. Aborts can be reduced by reducing the number of kick-outs.

[0043] Referring to Figures 1 and 2, the system 100 and/or computing device 201 can include a rattle engine and/or a rattle module, respectively. The rattle engine can include hardware and/or a combination of hardware and program instructions to assign a rattle-count to each key within a slot. In some examples, the rattle engine can track a total number of time a key has been kicked-out of any slot in any bin.

[0044] In accordance with examples of the present disclosure, a rattle-counter can provide a selection hierarchy and increased efficiency to a kick-out scheme. As illustrated in Figure 4, a hash table can include a bin 403 with a number of slots 426-1 , 426-2, 426-3, and 426-4, generally referred to as 426. The bin 403 can include a number of slots 426. The number of slots 426 can include a key (e.g., A, B, C, D) within each of the slots 426.

[0045] Each hash function can map to a bin 403, which can contain a number of keys (e.g., digital records) in the slots 426. There can be d hash functions, referred to as ho, hz . . . hd-i. When a first thread 430 wishes to insert a key into a slot 426 in the bin 403, the first thread 430 can attempt to insert the key into one of the bins assigned to the d hash functions (e.g., 403). However, if each of the slots 426 within the bin 403 include a key, the first thread 430 may resort to a kick-out.

[0046] For example, a first thread 430 may wish to insert a first key, x, into the bin 403. The first thread 430 can seek an empty slot before resorting to kicking-out a key in a slot 426. As shown in Figure 4, an empty slot within the bin 403 is absent. The first thread 430 can attempt to insert a key, x, into the bin 403, however, each of the slots 426 can have associated keys. For instance, the first thread 430 can attempt to insert a key, x, into slots 426-1 , 426-2, 426-3, and 426-4, but may not be able to due to associated keys A, B, C, and D within the respective slots 426. Absent empty slots within the bin 403, the first thread 430 may resort to kicking-out and may seek to find a key to kick -out of a slot 426.

[0047] In some examples, the number of keys in slots 426-1 , 426-2, 426-3, and 426-4 can include a respective rattle-counter 434-1 , 434-2, 434-3, and 434-4, generally referred to as 434. The rattle counters 434 can be maintained by a rattle counter engine in system 100 and/or a rattle counter module in computing device 201 . The rattle-counter 434 can refer to a numerical value that changes based on the number of times the respective key is kicked-out of any slot 426 in any bin 403. That is, the rattle- counter 434 can be initialized at zero and incremented each time a key is kicked out of a slot 426 and/or bin 403. Using the rattle-counter, kick-out schemes can have an order and/or a hierarchy in identifying a particular key from a slot 426 to kick-out.

[0048] For example, a first thread 430 can compare the rattle-counter 434 of a first key 434-1 and a rattle-counter 434-3 of a second key within a slot in the bin 403. The key possessing a larger (e.g., higher numerical value) rattle-counter can be given priority. That is, the key possessing the larger rattle-counter number can remain residing in the slot 426 in the bin 403, while the other key is kicked out. For instance, as depicted in Figure 4, the first thread can select from keys A, B, C, D, and x. The key B associated with slot 426-2 possesses a rattle-counter number lower than keys A, C, D, and x. The first thread 430 can kick-out 436 key B from slot 426-2 and insert key x. Since each key can already be assigned to two or more bins, key B, when selected for kick-out 436, can be moved to one of the other bins to which it is assigned.

[0049] In some examples, the key that is kicked-out of a slot 426 can have its associated rattle-counter incremented to reflect the respective number of times it has been kicked-out of the slot 426. In some examples, the key possessing the smallest (e.g., lowest numerical value) can automatically be selected for kick-out. That is, when comparing two or more keys, the key possessing the higher numerical value, can reside in the slot 426.

[0050] Additionally, and/or alternatively, the key attempting to enter the slot may not be exempt from being the key kicked-out. That is, a key associated with the first thread 430 may possess the lowest rattle-counter. A key associated with the first thread possessing the lowest rattle-counter (e.g., lowest numerical value) among the plurality of keys (e.g., A, B, C, D), can have its rattle count increased (e.g., to 1 ) and move to a second bin to compare rattle-counts with the keys in the second bin (e.g., E, F, G, H). The key associated with the first thread 430 can continue comparing rattle-counts with keys located in different bins as an iterative process. Each time the key associated with the first thread 430 moves to a different bin, the key can increase its rattle-count (e.g., to 2, to 3, etc.). The comparison between rattle-counts within bins can continue until the key associated with the first thread 430 identifies a key in a slot with a lower rattle- count. The key associated with the first thread 430 can kick out the key in the bin possessing the lowest rattle-count. The key that is selected for kick-out can then move to another bin to which it is hashed.

[0051] The rattle-counter 434, in some examples, can determine which hash function can be used in a key's kick-out. For example, if there is a rattle-counter of 2 for a key selected to be kicked -out of a bin, then the third hash function i3 can be used to determine the bin into which the key (e.g., record) may be kicked. In some instances, the key selected for kick-out having a rattle count j can result in the use of the hash function h_{j mod d}.. That is, the rattle-counter can determine which hash function to use, such that usage may be equally distributed among the hash functions for a given key.

[0052] Figure 5 illustrates an example of a method 505 for reducing cuckoo hashing aborts, accordingly to the present disclosure. At 538, the method 505 for reducing cuckoo hashing aborts can include assigning a rattle-counter to each key among a plurality of keys in each bin among a plurality of bins in a cuckoo hash table. For example, referring to Figure 4, the method 505 can include assigning a rattle- counter 434 to each key 426 in the bin 403. As described in relation to Figures 1 , 2, and 4, the rattle-counter can be assigned using a rattle counter engine and/or a rattle counter module.

[0053] At 540, the method 505, in some examples, can include incrementing the rattle-counter associated with each key in each bin based on a number of times each key has been kicked out of a bin in the cuckoo hash table. The rattle-counter can provide an indication of a particular hash function applicable to a kick-out. For instance, referring to Figures 1 and 2, a rattle-counter engine and/or a rattle-counter module, respectively, can increment a rattle-count for a particular key, based on a number of times the key has been kicked out of a bin (e.g., 403) in the cuckoo hash table.

[0054] At 542, the method 505 can include selecting a bin among the plurality of bins based on the rattle-counter associated with each key in each bin. For instance, referring to Figures 1 and 2, the system 100 and/or computing device 201 can include a bin selection engine and/or a bin selection module, respectively. The bin selection engine can include hardware and/or a combination of hardware and program instructions to select a bin among the plurality of bins based on the rattle-counter associated with each key in each bin. Selecting the bin can include kicking-out a first key in a first bin among the plurality of bins based on the incremented rattle-counter of the first key. That is, as discussed previously in association with Figure 4, the key possessing the lowest rattle-count (e.g., lowest numerical value) among the keys in the bin, can be selected for kick-out. The method 505 can further include inserting a second key in the first bin.

[0055] Some examples of the method 505 can also include inserting a claim flag by a first thread indicating to a second thread the bin is reserved (e.g., a thread intends to edit the slot) by the first thread for a first insertion key. For instance, referring to Figures 1 and 2, the claim flag engine 1 10 and/or the claim flag module 222,

respectively, can insert a claim flag by a first thread indicating to a second thread that the slot is reserved. That is, the rattle-counter and the claim flag (e.g., claim flag 332 as discussed in association with Figure 3) can operate cohesively. For example, a claim flag can be inserted to a slot by a first thread, while a second thread can be performing a kick-out using the rattle-counter. Both operations can function concurrently to reduce cuckoo hashing aborts.

[0056] Figure 6 illustrates a flow diagram of an example method of reducing cuckoo hashing aborts, according to the present disclosure. When a hash table becomes very full, the number of bins viewed per insertion increases, and insertions can become slower. Slow insertions may cause more opportunities for threads to conflict, leading to aborts. Figure 6 depicts a variant of a cuckoo hashing method in which there can be more than two hash functions.

[0057] In some examples, at 644 a kick-out chain sequence for a particular key can be determined with the aid of a list of keys (e.g., record). As illustrated at 644 in Figure 6, the kick-out chain sequence can be determined for key "x". For example, referring to Figure 3, a kick-out chain sequence for each of keys x, A, C, and D, can be maintained. This "kick-out chain sequence" or list of keys associated with a key within a cuckoo hash table can be constructed during an insertion to facilitate finding a kick-out chain. In some instances, the list can be maintained by a statistic. [0058] The list can include keys associated with a particular key, which can be used as a form of exploratory chain routing, such as search-tree. That is, the list can be used to determine a kick-out chain for a key associated with a cuckoo hash table. The shorter the list, the fewer the bins viewed to find a kick-out chain, and the faster (e.g., decreased period of time) an insertion action may be performed. In turn, quicker insertions can lead to reduced opportunities for threads to collide.

[0059] A plurality of child keys from a parent key can be identified for each key among the list of keys. Child bins, as used herein, are the set of bins hashed to the key (e.g., record), but not containing the parent key. Child keys, as used herein, are the set of keys contained in the child bins. For instance, hashing a key (e.g., key illustrated in Figure 3) into a first bin (e.g., bin 303 illustrated in Figure 3) and second bin (e.g., not illustrated in Figure 3), and then inserting the key into the first bin, can result in the second bin being termed a "child bin".

[0060] Spawning a key, as used herein, refers to the act of viewing a key's children bins as part of a search for a kick-out chain. The spawn-count of a key can represent the number of times that the key had been spawned in its existence. In some instances, when a key x is first inserted into a cuckoo hash table, its spawn count may be initialized at zero and its list (e.g., for the purposes of a search) may be initialized to contain x at 646. Until a kick-out chain is identified, the following search process may be conducted iteratively.

[0061] Based on the list, at 648 the smallest spawn count key R from the list can be selected. R can be removed from the list, and R's children bins can be viewed. Additionally, in some examples, R's spawn count can be incremented. If any of R's children bins contain an empty slot, the search may be terminated and the kick-out chain sequence identified can run its course.

[0062] Additionally, and/or alternatively, if none of R's children bins contain an empty slot, then all of R's children keys may be inserted into the list. The process can be repeated at 648. That is, the new smallest spawn-count key may be selected from the list 648 and its children bins may be examined.

[0063] For example, a kick-out chain for a key x being inserted by a thread can be created. The list can initially contain x at 646. If neither of x's children bins have an empty slot 650, then x can be removed from the list and x's children keys can be added to the list 654. These keys may be A, B, C, D, E, F, G, and H. Because the search visited x's children keys, x's spawn count can be incremented. In this example, perhaps key A possesses the lowest spawn count of the keys in the list 648. That is, key A may have been spawned by searches the fewest times of the keys in the list.

[0064] Further, according to the example, perhaps each of key A's children bins do not contain an empty slot at 650. Key A can be removed from the list and its children keys can be added to the list at 654. For instance, the children keys of key A may include keys I, J, K, and L. Since the search visited key A's children keys, key A's spawn count can be incremented. Perhaps, in this example, key J possesses the lowest spawn count among the keys in the list at 648. Perhaps one of key J's children bins, bin B, contains an empty slot 650. The following kick-out chain, in this example, may include J kicked into bin B, key A can be kicked into key J's previous slot, and key x can be inserted 652 into key A's previous slot. Since key J's children keys have been viewed as part of a search, key J's spawn count can be incremented. Alternatively, if key J's children bins had not contained an empty slot 650, then the process may continue until a kick-out chain is identified.

[0065] In addition, and/or alternatively, in some examples, several keys may be selected at once at 648 and both may be spawned. This can facilitate the use of prefetching. That is, keys may be prefetched based on their spawn count during a search for a kick-out chain (e.g., pathway). Multiple keys can be fetched at once via a memory resource, as discussed in relation to Figure 7.

[0066] Alternatively, or additionally, in some examples a statistic besides the spawn count may be used to select a key. For example, rather than selecting a key with the smallest spawn count from the list, 648, the key that was least recently spawned during any search may be selected.

[0067] The spawn count, in some examples, can be capped for a bin in the cuckoo hash table at a particular value. For instance, the spawn count can be capped (e.g., limited) at four bits. Capping the spawn count can increase efficiency by decreasing space usage. [0068] Figure 7 illustrates a diagram of an example computing device 709 for reducing cuckoo hashing aborts according to the present disclosure. For example, the computing device 709 may be an implementation of the example method of Figure 6. The computing device 709 can utilize hardware, software (e.g., program instructions), firmware, and/or logic to perform a number of functions described herein. The computing device 709 can be any combination of hardware and program instructions configured to share information. The hardware can, for example, include a processing resource 760 and a memory resource 762 (e.g., computer or machine readable medium (CRM/MRM), database, etc.). A processing resource 760, as used herein, can include one or more processors capable of executing instructions stored by the memory resource 762. The processing resource 760 may be implemented in a single device or distributed across multiple devices. The program instructions (e.g., computer or machine readable instructions (CRI/MRI)) can include instructions stored on the memory resource 762 and executable by the processing resource 760 to perform a particular function, task and/or action (e.g. insert a claim flag within a slot.).

[0069] The memory resource 762 can be a non-transitory machine readable medium, including one or more memory components capable of storing instructions that can be executed by a processing resource 760, and may be integrated in a single device or distributed across multiple devices. Further, memory resource 762 may be fully or partially integrated in the same device as processing resource 760 or it may be separate but accessible to that device and processing resource 760. Thus, it is noted that the computing device 709 may be implemented on a participant device, on a server device, on a collection of server devices, and/or a combination of a participant, (e.g., user/consumer endpoint device), and one or more server devices as part of a

distributed computing environment, cloud computing environment, etc.

[0070] The memory resource 762 can be in communication with the processing resource 760 via a communication link (e.g., a path) 770. The communication link 770 can provide a wired and/or wireless connection between the processing resource 760 and the memory resource 762.

[0071] In the example of Figure 7, the memory resource 762 includes a list module 764 to maintain a list of keys associated with a cuckoo hash table. For example, the list module 764 can include instructions executable by the processing resource 760 to maintain a list of keys, such as bins, associated with a particular key.

[0072] Also, the memory resource 762 can include an identify spawn keys module 766 to identify spawn keys associated with the particular key. For example, the spawn keys can identify a bin in the cuckoo hash table associated with the particular key but not containing the particular key itself. That is the instructions can be

executable to identify the child keys of the particular key.

[0073] Further, the memory resource 762 can include an assign a spawn count module 768 to count a number of times that a search reviewed a plurality of child keys associated with the key, as described previously in relation to Figure 6. In addition, instructions stored on the example medium 762 can be executable by the processor 760 to key the set of bins hashed to the key associated with the spawn count. The plurality of modules may be combined or may be sub-modules of other modules. As shown in Figure 7, the list module 764, the identify spawn keys module 766, and the spawn count module 768 can be individual modules located on one memory resource 762. Embodiments are not so limited, however, and a plurality of modules can be located at separate and distinct memory resource locations, for example, in a distributed computing environment, cloud computing environment, etc.

[0074] Additionally, the computing device 709 illustrated in Figure 7 can be the analogous to the computing device 201 illustrated in Figure 2. For example, processing resource 212 can be analogous to processing resource 760, and memory resource 216 can be analogous to memory resource 762. For instance, memory resource 216 can include a hash table module, a thread receipt module, a claim flag module, a list module, an identify spawn keys module, and an assign a spawn count module, as described herein.

[0075] In the present disclosure, reference is made to the accompanying drawings that form a part hereof, and in which is shown by way of illustration how a number of examples of the disclosure may be capable of being practiced. These examples are described in sufficient detail to enable those of ordinary skill in the art to practice the examples of this disclosure, and it is to be understood that other examples may be capable of being used and that process, electrical, and/or structural changes may be capable of being made without departing from the scope of the present disclosure.

[0076] The figures herein follow a numbering convention in which the first digit corresponds to the drawing figure number and the remaining digits identify an element or component in the drawing. Elements shown in the various figures herein may be capable of being added, exchanged, and/or eliminated so as to provide a number of additional examples of the present disclosure. In addition, the proportion and the relative scale of the elements provided in the figures are intended to illustrate the examples of the present disclosure, and should not be taken in a limiting sense.

[0077] As used herein, "logic" is an alternative or additional processing resource to perform a particular action and/or function, etc., described herein, which includes hardware (e.g., various forms of transistor logic, application specific integrated circuits (ASICs), etc.) as opposed to computer executable instructions (e.g., firmware, etc.) stored in memory and executable by a processor. Further, as used herein, "a" or "a number of something can refer to one or more such things. For example, "a number of widgets" can refer to one or more widgets. Also, as used herein, "a plurality of something can refer to more than one of such things.

[0078] The above specification, examples and data provide a description of the method and applications, and use of the system and method of the present disclosure. Since many examples may be capable of being made without departing from the spirit and scope of the system and method of the present disclosure, this specification merely sets forth some of the many possible example configurations and implementations.

Claims

What is claimed:

1 . A cuckoo hashing system, comprising:

a hash table engine to maintain a cuckoo hash table including a slot;

a thread receipt engine to receive a first thread including a first insertion key and a second thread including a second insertion key; and

a claim flag engine to insert a claim flag in the slot by the first thread, wherein the claim flag indicates to the second thread that the slot is reserved by the first thread for the first insertion key.

2. The system of claim 1 , including the claim flag engine to prevent insertion of the second insertion key into the slot by the second thread.

3. The system of claim 1 , wherein the cuckoo hash table is serializable and uses an optimistic concurrency scheme.

4. The system of claim 1 , including the claim flag engine to change a value of a bit associated with the slot to indicate the slot is reserved.

5. The system of claim 1 , including the claim flag engine to allow read-access of information stored in the slot to the second thread.

6. The system of claim 1 , including the thread receipt engine to implement a lock operation by the first thread to lock the slot and commit the first insertion key.

7. A non-transitory computer readable medium having computer-executable instructions stored thereon and executed by a processor to cause the computer to: maintain a list of keys associated with an insertion in a cuckoo hash table;

identify a plurality of child keys for each key among the list of keys; assign a spawn count to each key among the list of keys, wherein the spawn count represents a number of times that a search reviewed the plurality of child bins of the key; and

select a key among the list of keys to spawn in a kick-out chain search based on the spawn count of the selected key.

8. The non-transitory computer readable medium of claim 7, wherein each child key among the plurality of child keys identifies a bin in the cuckoo hash table associated with the key but not containing the key.

9. The non-transitory computer of claim 7, wherein the spawn count is incremented based on the number of times a search reviews children bins.

10. The non-transitory computer of claim 9, wherein instructions to select a key includes selection of a plurality of keys and spawning the plurality of keys.

1 1 . A method for a cuckoo hashing, comprising:

assigning a rattle-counter for each key among a plurality of keys in each slot among a plurality of bins in a cuckoo hash table;

incrementing the rattle-counter associated with each key in each bin based on a number of times each key has been kicked out of a bin in the cuckoo hash table; and selecting a key to be kicked out of the bin based on the incremented rattle- counter.

12. The method of claim 1 1 , wherein selecting the bin further comprises:

kicking-out a first key in a first slot among the plurality of slots based on the incremented rattle-counter of each key among the plurality of keys, wherein the keys are compared numerically and ties are decided arbitrarily; and

inserting a second key in the first bin.

13. The method of claim 1 1 , wherein the rattle-counter further comprises an indication of a particular hash function applicable to a key.

14. The method of claim 1 1 , further comprising inserting a claim flag by a first thread indicating to a second thread the bin is reserved by the first thread for a first insertion key.

15. The method of claim 1 1 , further comprising comparing the rattle-counters associated with two or more keys to determine a key among the plurality of keys to kick out of the bin.