WO2020125741A1

WO2020125741A1 - Hash collision processing method, apparatus, device, and computer readable storage medium

Info

Publication number: WO2020125741A1
Application number: PCT/CN2019/126860
Authority: WO
Inventors: 王磊; 刘明强
Original assignee: 中兴通讯股份有限公司
Priority date: 2018-12-21
Filing date: 2019-12-20
Publication date: 2020-06-25
Also published as: CN111352931A

Abstract

The present application discloses a hash collision processing method, an apparatus, a device, and a computer readable storage medium. Said method comprises: acquiring a key and a result value that are to be inserted into a hash table; using at least two different pre-set hash functions to perform a hash operation of the key respectively, to obtain at least two hash values; and in the case where it is determined, according to the obtained hash values and a pre-established index table for storing indexes, that the key will not cause any hash collision, allocating, to the key, a target index different from a historical index, the historical index being an index corresponding to a key existing in the hash table; and adding the key and the result value into the hash table with the target index as an address.

Description

Hash conflict processing method, device, equipment and computer readable storage medium

This application requires the priority of the Chinese patent application filed on December 21, 2018 with the Chinese Patent Office, application number 201811571387.0. The entire contents of this application are incorporated by reference in this application.

Technical field

The embodiments of the present application relate to the technical field of network communication, for example, to a method, device, device, and computer-readable storage medium for processing hash collisions.

Background technique

The hash algorithm is to map a key value of k bit width to an index value of n bit width, k>n. For example, the key is 200-bit wide binary data, which must be mapped to a 20-bit wide binary data index by hash. Since the sample space of the key is obviously much larger than the sample space of the index, during the mapping process, for different key values: key1 and key2, the index after the hash mapping is the same, which is the hash conflict. The hash table is based on a hash algorithm, a data structure network that stores the corresponding key value and other entry information with the index as the address. The hash table is often used in the device for route lookup and data forwarding. When a hash conflict occurs, It will cause route lookup errors and data forwarding failure.

In the related art, the method to solve the hash conflict is to expand the hash table, divide the hash table address pointed to by an index into M positions (slots), and each slot stores a different key, so that the original N storage The hash table space of the unit is expanded to M*N storage units. When a hash conflict occurs, different keys are stored in different slots in the address pointed to by the same index.

However, since the hash table needs to be stored using a memory, when the hash table is expanded, it means that the storage of the hash table requires a larger capacity of memory, so it will increase the overhead of the device; on the other hand, because the memory has Data bit width limitation. When the data bit width of a hash table address is too large, it is necessary to access the memory multiple times to read out the information of all slots in the space, so the lookup speed of the hash table will be reduced.

Summary of the invention

Embodiments of the present application provide a method, device, device, and computer-readable storage medium for processing hash conflicts, which can reduce hash conflicts without expanding the hash table.

An embodiment of the present application provides a method for processing hash conflicts, including:

Get the key value and result value to be inserted into the hash table;

Performing hash operation on the key value by using at least two different hash functions preset in advance to obtain at least two hash values;

When it is determined that the key value does not cause a hash conflict based on the obtained hash value and the pre-established index table for storing the index value, a target index that is different from the historical index value is assigned to the key value Value; wherein, the historical index value is an index value corresponding to the key value already in the hash table;

The key value and the result value are added to the hash table with the target index value as the address.

An embodiment of the present application further provides a device for processing hash conflicts, including:

The acquisition module is set to acquire the key value and the result value to be inserted into the hash table;

An operation module, configured to perform a hash operation on the key value using at least two different hash functions set in advance to obtain at least two hash values;

The processing module is configured to allocate a historical index value to the key value when it is determined that the key value does not cause a hash conflict based on the obtained hash value and the pre-established index table for storing the index value Different target index values; wherein, the historical index value is an index value corresponding to the key value already in the hash table;

The adding module is configured to add the key value and the result value to the hash table with the target index value as the address.

An embodiment of the present application further provides a hash collision processing device, including: a processor and a memory, where the memory stores the following instructions that can be executed by the processor:

Get the key value and result value to be inserted into the hash table;

Hashing the key value by using at least two preset different hash functions to obtain at least two hash values;

An embodiment of the present application further provides a computer-readable storage medium, on which the computer-executable instructions are stored, and the computer-executable instructions are used to perform the following steps:

Get the key value and result value to be inserted into the hash table;

BRIEF DESCRIPTION

FIG. 1 is a schematic structural diagram of a hash table in the related art;

2 is a schematic diagram of a structure of a hash table expanded to deal with hash conflicts in the related art;

FIG. 3 is a schematic flowchart of a method for processing a hash conflict provided by an embodiment of this application;

4 is a schematic structural diagram of an index table provided by an embodiment of this application;

FIG. 5 is a schematic structural diagram of a device for processing hash conflicts according to an embodiment of the present application;

FIG. 6 is a schematic structural diagram of another hash collision processing apparatus provided by an embodiment of the present application.

detailed description

Hereinafter, embodiments of the present application will be described in detail with reference to the accompanying drawings.

The steps shown in the flowcharts of the figures can be performed in a computer system such as a set of computer-executable instructions. And, although a logical order is shown in the flowchart, in some cases, the steps shown or described may be performed in an order different from here.

FIG. 1 is a schematic structural diagram of a hash table in the related art, and FIG. 2 is a schematic structural diagram of a hash table expanded in the related art to handle hash conflicts. As shown in FIG. 1, the hash table includes N storage units. As shown in FIG. 2, the hash table is based on the hash table shown in FIG. The storage units have been expanded (that is, each storage unit has been expanded to 4 slots), and the hash table shown in Figure 1 has been expanded to a hash table with 4*N storage units. When a hash conflict occurs, different keys The values are stored in different slots in the address pointed to by the same index, effectively solving the hash conflict. However, since the hash table needs to be stored using a memory, when expanding the hash table, it means that storing the hash table requires a larger capacity of memory to use double-rate synchronous dynamic random access memory (Double Data Rate SDRAM, DDR) The storage hash table is used as an example. When the hash table is stored in DDR, the larger the hash table, the more DDR particles are required. Due to hardware design and cost control, the number of DDR particles used is limited and cannot be met. Oversized hash table. Moreover, due to the limitation of the data bit width of DDR, when the data bit width of a hash table address is too large, it is necessary to access the DDR multiple times to read out the information of all slots in the space, which will reduce the speed of the hash table lookup. In data forwarding applications, the performance of route lookup and data forwarding will be severely deteriorated, making it impossible to achieve wire speed.

To this end, an embodiment of the present application provides a method for processing hash conflicts. As shown in FIG. 3, the method includes:

Step 1010: Obtain the key value and the result value to be inserted into the hash table.

The action value is action information on how to operate the key value.

Step 1020: Perform a hash operation on the key values to be inserted into the hash table using at least two preset different hash functions to obtain at least two hash values.

The number of the at least two hash functions preset may be two or more than two, which can be set according to circumstances. When the number of preset hash functions is greater, the incidence of hash collisions can be reduced, but the complexity of the implementation of the corresponding method and the consumption of computing resources will increase.

Step 1030. If it is determined that the key value to be inserted into the hash table does not cause a hash conflict based on the obtained hash value and the pre-established index table for storing the index value, the value is inserted into the hash table The key value of is assigned a target index value that is different from the historical index value.

In this embodiment, the historical index value is an index value corresponding to the key value already in the hash table.

Step 1040: Write the key value and the result value to be inserted into the hash table into the hash table with the target index value as the address.

The method for processing hash conflicts provided in the embodiments of the present application, since determining whether the key value to be inserted into the hash table will cause the hash conflict to be based on at least two hash functions is obtained based on the hash value, is different from The hash function of the method reduces the probability of hash collision, and after determining that the key value to be inserted into the hash table will not cause a hash conflict, the key value to be inserted into the hash table is assigned to the hash table. The target index value corresponding to the index value corresponding to the existing key value in the target index value is used as the address of the key value and the result value to be inserted into the hash table, and it must be the address of the key value already existing in the hash table. Not the same, thereby reducing hash conflicts without expanding the hash table, saving equipment overhead, and improving the lookup speed of the hash table.

Optionally, the at least two different hash functions preset include: a first hash function and a second hash function.

Perform a hash operation on the key value to be inserted into the hash table to obtain at least two hash values including:

The first hash function is used to perform a hash operation on the key value to be inserted into the hash table to obtain the first hash value.

The second hash function is used to perform a hash operation on the key value to be inserted into the hash table to obtain a second hash value.

In one embodiment, the index table includes: multiple addresses.

Each address includes: multiple locations.

Each position includes: a first field, a second field, and a third field; where the first field is used to store the hash value obtained by hashing the key value using the second hash function; the second field is used It is used to store the index value; the third field is used to store the mark indicating whether each position is occupied.

In this embodiment, the product of the number of addresses of the index table and the number of positions of each address is not less than the number of addresses of the hash table.

The index value and the hash value are in one-to-one correspondence. How many hash values are in the hash table and how many corresponding index values are in the index table, so the maximum number of hash values that can be stored in the hash table should be The number considers the size of the index table. The maximum number of hash values that the hash table can store is the number of addresses in the hash table, and the index table is used to store the index value is the position, so the number of positions in the index table The number cannot be less than the number of addresses in the hash table, that is, the product of the number of addresses in the index table and the number of positions in each address is not less than the number of addresses in the hash table.

The number of the address of the index table is the depth of the index table. The bit width of the hash value obtained by the first hash function hashing the key value determines the depth of the index table, thereby ensuring that the address of the index table It can be found by searching the corresponding address with the first hash value, assuming that the bit width of the hash value obtained by the first hash function hashing the key value is i, and the depth of the index table is 2 ⁱ , when i = 10. The depth of the index table is 2 ¹⁰ .

Marks can include: digital marks, letter marks and symbol marks. When the mark is a digital mark, two different numbers can be used to indicate that the position is occupied and the position is not occupied; when the mark is a letter mark, two different letters can be used to indicate that the position is occupied and the position is not occupied; When the mark is a symbol mark, two different symbols can be used to indicate that the position is occupied and the position is not occupied.

In an embodiment, the pre-established index table may be as shown in FIG. 4, the depth of the index table (that is, the number of addresses of the index table) is 2 ⁱ , each address includes 4 slots, and each slot includes: a mark ( flag) field (equivalent to the third field used to store the mark indicating whether the location is occupied), hash value (sig) field (equivalent to the second field used to store the index value) and index value (index) field ( It is equivalent to the first field for storing the hash value obtained by performing the hash operation on the key value using the second hash function).

Optionally, the method for processing hash conflicts further includes:

Find the address corresponding to the first hash value in the address of the index table as the target address.

Determine whether each location in the target address is occupied.

In response to the judgment result that all positions in the target address are not occupied, it is determined that the key value to be inserted into the hash table will not cause a hash conflict.

In response to the judgment result that a part of the position in the target address is occupied and the remaining part is not occupied, the second hash value and the index table are used to judge whether the key value to be inserted into the hash table will cause a hash conflict.

If a part of the target address is occupied and the remaining part is unoccupied, there is a possibility of hash conflict, so it is necessary to use the second hash value and the index table to determine whether the key value to be inserted into the hash table will cause ha Greek conflict.

Optionally, the second hash value and the index table are used to determine whether the key value to be inserted into the hash table will cause a hash conflict, including:

Obtain the hash value on the first field of all occupied positions in the target address as the hash value to be compared.

Determine whether the second hash value is the same as any one of the hash values to be compared.

In response to the judgment result that the second hash value is different from any one of the hash values to be compared, it is determined that the key value to be inserted into the hash table will not cause a hash conflict.

Optionally, after assigning a target index value different from the historical index value for the key value to be inserted into the hash table, the method further includes:

Add the second hash value to the first field of the first unoccupied position in the target address.

Add the target index value to the second field of the first unoccupied position in the target address.

Add a mark indicating that the position is occupied to the third field of the first unoccupied position in the target address.

In the method for processing hash conflicts provided by the embodiments of the present application, the size of the hash table and the sample space size of the key value are the same, and the hash table is not expanded. In order to reduce conflicts, an index table is introduced, and each key value is assigned a completely unique index value in the index table, so it will not duplicate the index value corresponding to the key value already existing in the hash table, thereby avoiding hashing conflict. In addition, in theory, the size of the index table should be consistent with the number of samples of the key value, but compared with the bit width of the hash table, the bit width of the index table is much smaller, so the index table can be expanded to achieve the purpose of reducing conflicts . When using DDR to store the index table, you can use only one read command to read the required index table information, because each key value has a unique index value, so as long as the index table hits, you can read it out with a single read operation The content of the hash table improves the query rate.

An embodiment of the present application provides a hash collision processing apparatus. As shown in FIG. 5, the hash collision processing apparatus 2 includes:

The obtaining module 21 is set to obtain the key value and the result value to be inserted into the hash table.

The operation module 22 is configured to perform a hash operation on the key values to be inserted into the hash table using at least two different hash functions set in advance to obtain at least two hash values.

The processing module 23 is set to determine that the key value to be inserted into the hash table will not cause a hash conflict if it is determined from the obtained hash value and the pre-established index table for storing the index value The key value of the hash table is assigned a target index value that is different from the historical index value; where the historical index value is an index value corresponding to the key value already in the hash table.

The adding module 24 is set to add the key value and the result value to be inserted into the hash table to the hash table with the target index value as the address.

The at least two different hash functions preset include: a first hash function and a second hash function.

The operation module 22 is configured to perform a hash operation on the key value to be inserted into the hash table using the first hash function to obtain the first hash value. The second hash function is used to perform a hash operation on the key value to be inserted into the hash table to obtain a second hash value.

Optionally, the index table includes: multiple addresses; each address includes: multiple locations; each location includes: a first field, a second field, and a third field; wherein, the first field is used to store and use the second The hash function obtains the hash value obtained by hashing the key value; the second field is used to store the index value; the third field is used to store the mark indicating whether each position is occupied. The product of the number of addresses of the index table and the number of positions of each address is not less than the number of addresses of the hash table.

Optionally, the processing module 23 is further configured to: find an address corresponding to the first hash value among the addresses of the index table as a target address; determine whether each position in the target address is occupied; respond to the target The judgment result that all positions in the address are unoccupied, and determine that the key value to be inserted into the hash table will not cause hash conflict; in response to the judgment result that some positions in the target address are occupied and the remaining positions are not occupied, use The second hash value and the index table determine whether the key value to be inserted into the hash table will cause a hash conflict.

Optionally, the processing module 23 is set to determine whether the key value to be inserted into the hash table will cause a hash conflict by using the second hash value and the index table as follows: acquiring the first of all occupied positions in the target address The hash value on the field is used as the hash value to be compared; determine whether the second hash value is the same as any one of the hash values to be compared; in response to the second hash value and any one of the hash values to be compared A judgment result of different hash values, it is determined that the key value to be inserted into the hash table will not cause a hash conflict.

Optionally, the adding module 24 is further configured to add the second hash value to the first field of the first unoccupied position in the target address.

Optionally, the adding module 24 is further configured to add the target index value to the second field of the first unoccupied position in the target address.

Optionally, the adding module 24 is further configured to add a mark indicating that the position is occupied to the third field of the first unoccupied position in the target address.

The apparatus for processing hash conflicts provided in the embodiments of the present application, since determining whether the key value to be inserted into the hash table will cause the hash conflict to be based on the hash value obtained based on at least two hash functions, is different from The hash function of the method reduces the probability of hash collision, and after determining that the key value to be inserted into the hash table will not cause a hash conflict, the key value to be inserted into the hash table is assigned to the hash table. The target index value corresponding to the index value corresponding to the existing key value in the target index value is used as the address of the key value and the result value to be inserted into the hash table, which must be the address of the key value already existing in the hash table. Not the same, thereby reducing hash conflicts without expanding the hash table, saving equipment overhead, and improving the lookup speed of the hash table.

In practical applications, the acquisition module 21, the calculation module 22, the processing module 23, and the addition module 24 can all be composed of a central processing unit (CPU) and a microprocessor (Micro Processor) located in a hash collision processing device Unit, MPU), digital signal processor (Digital Signal Processor, DSP) or field programmable gate array (Field Programmable Gate Array, FPGA) and so on.

An embodiment of the present application further provides a device for processing hash conflicts. As shown in FIG. 6, the device includes:

The hash function module 31 is set to accept the input key. There are two different hash functions inside the module, denoted as hash_i and hash_h. The hash function is used to hash the key and the two hash values are output as follows: The first hash value (Hi) and the second hash value (Hh).

The hash conflict processing module 32 is set to receive the two hash values output by the hash function module 31, and then process the hash conflict, and perform corresponding read and write operations on the index table and the hash table according to the operations of insertion, query, and deletion.

When the key is inserted, the action will also be entered with the key. First read the data from the index table with Hi as the address, then handle the hash conflict, and assign an index to the key, and write Hh and index to the corresponding position in the Hi address space of the index table. Then use the index as the address to write the key and action into the hash table.

During key query, only key is entered, there is no action, and the action is obtained from the hash table. First read the data from the index table with Hi as the address, and extract the hash value of the hash function hash_h from the returned data, marked here as Hh', and then use the Hh and Hh' generated by the current key to compare and select the position with the same result On the index, read the data from the hash table using the index as the address, and the key and action required by the hash table are returned.

When the key is deleted, only the key is entered, and there is no action. First read the data from the index table with Hi as the address, and extract Hh' from the returned data, then use the Hh and Hh' generated by the current key to compare, select the index at the position where the result is consistent, and then use index as the address from The hash table reads the data, and then compares the keys. If they are consistent, the deletion is successful. Write 0 to the hash table with the index as the address and clear the corresponding slot in the Hi address in the index table. Inconsistency means that the deletion failed.

Assume that the established index table is shown in FIG. 4, where when flag=0, it indicates that the slot is idle, and when flag=1, it indicates that the slot is occupied. The following describes the process of key insertion, key query and key deletion:

The key insertion process includes the following steps:

Step 110: Read the index table with Hi as the address, and read out all the slots in the Hi address space in the index table.

Step 120, the index table data is returned, and four slot flags are extracted from the returned data.

Step 130: From slot(1) to slot(4), find the first free slot through the flag, marked as slot(j), which is the slot position where the key is to be inserted. When all 4 slots are free, take j=1 and determine that the current key can be inserted, and skip to step 140; when all slots are occupied and the current entry cannot be inserted, skip to step 170; otherwise, skip to Step 150.

Step 140: Set flag=1 and sig=Hh, assign a new index to the current key, and then write the new flag (at this time flag=1), sig and index to the slot (1 in the Hi address space of the index table) ) Location, jump to step 160.

Step 150: Extract sig_h in the slot with flag=1. Then compare Hh with all extracted sig_h. If there is a match, it is determined that the key cannot be inserted. If there is no match, the key can be inserted. When insertable, assign a new index to the current key, and then write the new flag, sig, and index to the slot (j) position in the Hi address space of the index table, and jump to step 160; when not insertable, the insert fails , Jump to step 170.

Step 160: Using the newly allocated index as the address, write the key and action into the hash table.

Step 170: End the process.

The key query processing process includes the following steps:

Step 210, read the index table with Hi as the address, read out all the slots in the Hi address space in the index table, and jump to step 220.

Step 220, the index table data is returned, and four slot flags are extracted from the returned data.

Step 230: Mark the sig in the slot with flag=1 as sig_h. Then compare Hh with all sig_h. If there is a match, it indicates that the index table query is successful. The slot with the same sig_h and Hh is recorded as slot(h). If there is no match, the index query fails. When the index table query is successful, extract the index from slot (h), and jump to step 240; when the index table query fails, jump to step 250.

Step 240, read the hash table with the extracted index as the address, and extract the key and action fields from the returned data. If the extracted key is the same as the key used in the query, the hash table query is successful, and the action is the required query information. If they are inconsistent, the hash table query fails and the action is invalid. Go to step 250.

Step 250: End the process.

The key deletion process includes the following steps:

Step 310: Read the index table with Hi as the address, and read out all the slots in the Hi address space in the index table.

Step 320, the index table data is returned, and four slot flags are extracted from the returned data.

Step 330: Mark the sig in the slot with flag=1 as sig_h. Then compare Hh with all sig_h. If there is a match, it indicates that the index table query is successful. The slot with the same sig_h and Hh is recorded as slot(h). If there is no match, it indicates that the index table query fails. When the index table query is successful, extract the index from slot (h), and jump to step 340; when the index table query fails, jump to step 360.

Step 340, read the hash table with the extracted index as the address, extract the key and action fields from the returned data, and jump to step 350.

Step 350: Determine whether the read key is the same as the key used in the query. If they match, write all 0s to the hash table with the index as the address, and clear slot(h) in the index table with Hi as the address. If they are inconsistent, it indicates that the deletion has failed. Jump to step 360;

Step 360, end the process.

An embodiment of the present application also provides a hash collision processing device, including a memory and a processor, where the memory stores the following instructions that can be executed by the processor:

Get the key and result values to be inserted into the hash table.

Using at least two different hash functions set in advance to perform hash operations on the key values to be inserted into the hash table, respectively, to obtain at least two hash values.

When it is determined that the key value to be inserted into the hash table does not cause a hash conflict based on the obtained hash value and the pre-established index table for storing the index value, the key value to be inserted into the hash table Assign a target index value that is different from the historical index value; where the historical index value is the index value corresponding to the key value already in the hash table.

The key value and the result value to be inserted into the hash table are added to the hash table with the target index value as the address.

The memory stores the following instructions executable by the processor: performing a hash operation on the key value to be inserted into the hash table using the first hash function to obtain the first hash value.

Use the second hash function to perform a hash operation on the key value to be inserted into the hash table to obtain a second hash value.

Optionally, the index table includes: multiple addresses.

Each address includes: multiple locations.

The product of the number of addresses of the index table and the number of positions of each address is not less than the number of addresses of the hash table.

Optionally, the memory also stores the following instructions that can be executed by the processor:

Determine whether each location in the target address is occupied.

In response to the judgment result that a part of the position in the target address is occupied and the remaining part is not occupied, the second hash value and the index table are used to determine whether the key value to be inserted into the hash table will cause a hash conflict.

An embodiment of the present application also provides a computer-readable storage medium, on which a computer-executable instruction is stored, and the computer-executable instruction is used to perform the following steps:

Get the key and result values to be inserted into the hash table.

Optionally, the at least two different hash functions preset include: a first hash function and a second hash function. Computer executable instructions also perform the following steps:

Optionally, the index table includes: multiple addresses.

Each address includes: multiple locations.

Optionally, the computer executable instructions also perform the following steps:

Determine whether each location in the target address is occupied.

Claims

A method for processing hash conflicts includes:

Get the key value and result value to be inserted into the hash table;

Hashing the key value by using at least two preset different hash functions to obtain at least two hash values;

When it is determined that the key value does not cause a hash conflict based on the obtained hash value and the pre-established index table for storing the index value, a target index that is different from the historical index value is assigned to the key value Value; wherein, the historical index value is an index value corresponding to the key value already in the hash table;

The key value and the result value are added to the hash table with the target index value as the address.
The method according to claim 1, wherein the preset at least two different hash functions include: a first hash function and a second hash function;

The performing hash operation on the key value by using at least two preset different hash functions respectively to obtain at least two hash values includes:

Performing a hash operation on the key value using the first hash function to obtain a first hash value;

Use the second hash function to perform a hash operation on the key value to obtain a second hash value.
The method according to claim 2, wherein the index table includes multiple addresses, each address includes multiple locations, and each location includes a first field, a second field, and a third field;

Wherein, the first field is used to store a second hash value obtained by hashing a key value using the second hash function; the second field is used to store an index value; the third A field for storing a mark indicating whether each position is occupied; the product of the number of addresses of the index table and the number of positions of each address is not less than the number of addresses of the hash table.
The method of claim 3, further comprising:

Searching for an address corresponding to the first hash value among the addresses of the index table as a target address;

Determine whether each position in the target address is occupied;

In response to the judgment result that all positions in the target address are not occupied, it is determined that the key value does not cause the hash conflict;

In response to a judgment result that a part of the position in the target address is occupied and a position in the target address other than the part is not occupied, the key value is judged using the second hash value and the index table Whether it will cause the hash conflict.
The method according to claim 4, wherein the using the second hash value and the index table to determine whether the key value will cause a hash conflict includes:

Obtain the hash value on the first field of all occupied positions in the target address as the hash value to be compared;

Determine whether the second hash value is the same as one of the hash values to be compared;

In response to the judgment result that all of the second hash value and the hash value to be compared are different, it is determined that the key value does not cause the hash conflict.
The method according to claim 4 or 5, after the assigning a target index value different from the historical index value for the key value, further comprising:

Add the second hash value to the first field of the first unoccupied position in the target address.
The method according to any one of claims 4-6, after the assigning a target index value different from the historical index value for the key value, further comprising:

Add the target index value to the second field of the first unoccupied position in the target address.
The method according to any one of claims 4-7, after the assigning a target index value different from the historical index value for the key value, further comprising:

A mark indicating that the location is occupied is added to the third field of the first unoccupied location in the target address.
A device for processing hash conflicts, including:

The acquisition module is set to acquire the key value and the result value to be inserted into the hash table;

An operation module, configured to perform a hash operation on the key value using at least two different hash functions set in advance to obtain at least two hash values;

The processing module is configured to allocate a historical index value to the key value when it is determined that the key value does not cause a hash conflict based on the obtained hash value and the pre-established index table for storing the index value Different target index values; wherein, the historical index value is an index value corresponding to the key value already in the hash table;

The adding module is configured to add the key value and the result value to the hash table with the target index value as the address.
A processing device for hash collision includes: a processor and a memory, wherein the memory stores the following instructions executable by the processor:

Get the key value and result value to be inserted into the hash table;

Performing hash operation on the key value by using at least two different hash functions preset in advance to obtain at least two hash values;

When it is determined that the key value does not cause a hash conflict based on the obtained hash value and the pre-established index table for storing the index value, a target index that is different from the historical index value is assigned to the key value Value; wherein, the historical index value is an index value corresponding to the key value already in the hash table;

The key value and the result value are added to the hash table with the target index value as the address.
A computer-readable storage medium stores computer-executable instructions, and the computer-executable instructions are used to perform the following steps:

Get the key value and result value to be inserted into the hash table;

Hashing the key value by using at least two preset different hash functions to obtain at least two hash values;

When it is determined that the key value does not cause a hash conflict based on the obtained hash value and the pre-established index table for storing the index value, a target index that is different from the historical index value is assigned to the key value Value; wherein, the historical index value is an index value corresponding to the key value already in the hash table;

The key value and the result value are added to the hash table with the target index value as the address.