CN109376097B - Method for solving hash search learning and address aging conflict of multiple microengines - Google Patents
Method for solving hash search learning and address aging conflict of multiple microengines Download PDFInfo
- Publication number
- CN109376097B CN109376097B CN201811012989.2A CN201811012989A CN109376097B CN 109376097 B CN109376097 B CN 109376097B CN 201811012989 A CN201811012989 A CN 201811012989A CN 109376097 B CN109376097 B CN 109376097B
- Authority
- CN
- China
- Prior art keywords
- address
- hash
- shielded
- space
- locking
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Active
Links
- 230000032683 aging Effects 0.000 title claims abstract description 28
- 238000000034 method Methods 0.000 title claims abstract description 28
- 230000000977 initiatory effect Effects 0.000 claims abstract description 22
- 230000004044 response Effects 0.000 claims abstract description 8
- 238000004590 computer program Methods 0.000 claims description 3
- 239000011159 matrix material Substances 0.000 description 4
- 238000004364 calculation method Methods 0.000 description 2
- 238000013507 mapping Methods 0.000 description 2
- 238000012986 modification Methods 0.000 description 2
- 230000004048 modification Effects 0.000 description 2
- 230000007704 transition Effects 0.000 description 2
- 230000009286 beneficial effect Effects 0.000 description 1
- 230000003139 buffering effect Effects 0.000 description 1
- 238000013500 data storage Methods 0.000 description 1
- 230000007547 defect Effects 0.000 description 1
- 230000006870 function Effects 0.000 description 1
- 238000005215 recombination Methods 0.000 description 1
- 230000006798 recombination Effects 0.000 description 1
- 238000010845 search algorithm Methods 0.000 description 1
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F12/00—Accessing, addressing or allocating within memory systems or architectures
- G06F12/02—Addressing or allocation; Relocation
- G06F12/08—Addressing or allocation; Relocation in hierarchically structured memory systems, e.g. virtual memory systems
- G06F12/0802—Addressing of a memory level in which the access to the desired data or data block requires associative addressing means, e.g. caches
- G06F12/0864—Addressing of a memory level in which the access to the desired data or data block requires associative addressing means, e.g. caches using pseudo-associative means, e.g. set-associative or hashing
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F12/00—Accessing, addressing or allocating within memory systems or architectures
- G06F12/02—Addressing or allocation; Relocation
- G06F12/08—Addressing or allocation; Relocation in hierarchically structured memory systems, e.g. virtual memory systems
- G06F12/10—Address translation
- G06F12/1009—Address translation using page tables, e.g. page table structures
- G06F12/1018—Address translation using page tables, e.g. page table structures involving hashing techniques, e.g. inverted page tables
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/46—Multiprogramming arrangements
- G06F9/52—Program synchronisation; Mutual exclusion, e.g. by means of semaphores
- G06F9/526—Mutual exclusion algorithms
Abstract
The invention provides a method for solving hash search learning and address aging conflicts of multiple microengines, which comprises the steps of establishing and maintaining a hash locking address cache space, and setting space capacity for the hash locking address cache space; starting response engine access, initiating a locking request to a hash address searched by hash learning, judging whether the hash address searched by the hash learning has address conflict or not, if the address does not conflict, judging whether the space capacity of a hash locking address buffer space is enough or not, if the buffer space is enough, locking the address, and initiating an unlocking request to the hash address and unlocking the hash address when the hash learning search process is finished. The invention adopts the buffer space for maintaining a hash locking address and the address locking protection, so that the address is only opened for the searching or learning or aging operation of a certain micro-engine, and the MEM operation during the hash address conflict is solved.
Description
Technical Field
The invention relates to the field of data storage and search and route exchange of computer technology, in particular to a method for solving hash search learning and address aging conflicts of multiple microengines.
Background
In the three-layer exchange project, 32 microengines (namely, processor cores in charge of a search algorithm) exist in a search module, for a two-layer frame, each frame needs to generate 3 keys to access a search memory, and the 3 keys are a hash learning key, a hash search key and a table search key respectively. the table lookup key only performs lookup access on the table, but does not modify the content of the table at all, but the hash learning key and the hash lookup key modify the content of the hash table, including aging, adding new table entries, deleting table entries, and updating refresh bits. Thus, 22 of the 32 search engines modify the search memory ((32/3) x2) simultaneously. At this time, if a plurality of microengines access and modify the content in the same address in the memory, a conflict will occur.
Patent document CN101655821B discloses a method and device for solving address space mapping hash address conflict, which cross-converts an index address into a reassembly address according to cross matrix configuration, and performs hash calculation on the reassembly address to obtain a hash address; the cross matrix configuration is a cross matrix configuration with high hardware resource utilization as confirmed by the mapping rule of index addresses to recombination addresses. The above patent document adopts a cross matrix configuration to cross-convert an index address into a reassembly address, and performs hash calculation on the reassembly address to obtain a hash address. But the relative realization complexity is high, and the requirement on hardware resources is also high.
Disclosure of Invention
Aiming at the defects in the prior art, the invention aims to provide a method for solving the Hash search learning and address aging conflict of multiple microengines.
The method for solving the Hash search learning and address aging conflict of the multiple microengines comprises the following steps:
establishing a Hash locking address cache space: creating and maintaining a hash locking address cache space, setting space capacity for the hash locking address cache space, and recording the space capacity as a cache space capacity value;
starting a Hash learning search step: starting to respond to engine access, and initiating a locking request to the hash address searched by the hash learning;
an address conflict judging step: judging whether the hash address searched by the hash learning has address conflict or not to obtain a conflict judgment result;
and finishing the Hash learning search step: and initiating an unlocking request to the hash address searched by the hash learning according to the collision judgment result.
Preferably, the address conflict determination step includes:
and an address comparison step: comparing the hash address searched by the hash learning with the address in the hash locking address buffer space, if the hash address searched by the hash learning has the same address as the address in the hash locking address buffer space, recording the result as a first comparison result, and if the hash address searched by the hash learning does not have the same address as the address in the hash locking address buffer space, recording the result as a second comparison result;
an engine shielding step: if a first comparison result is obtained after the address comparison, the locking request is shielded, the shielded address is marked as a first shielded address, the first shielded address is added into a shielded address set, and a shielded engine, a shielded address and engine initiation request time are stored in the shielded address set;
an engine response step: and responding to the locking request if a second comparison result is obtained after the address comparison.
Preferably, the method for solving the hash lookup learning and address aging conflict of the multiple microengines further comprises a cache space judgment step;
a cache space judgment step: the method comprises the steps of calculating the space capacity of a Hash locking address buffer space, obtaining a first space capacity, comparing the first space capacity with a cache space capacity value, judging that the Hash locking address buffer space has a vacant space if the first space capacity is smaller than the cache space capacity value, and judging that the Hash locking address buffer space has no vacant space if the first space capacity is equal to the cache space capacity value.
Preferably, the method for solving the hash search learning and address aging conflict of the multi-micro engine further comprises an address unlocking step; and (3) address unlocking: and comparing the unlocked address with the shielded address in the shielded address set, responding to an engine corresponding to the shielded address if the unlocked address is the same as the shielded address in the shielded address set, deleting the unlocked address from the hash locking address cache space if the unlocked address is not the same as the shielded address in the shielded address set, and responding to the shielded engine in the shielded address set.
The system for solving the hash search learning and address aging conflict of the multiple microengines comprises the following modules:
establishing a Hash locking address cache space module: creating and maintaining a hash locking address cache space, setting space capacity for the hash locking address cache space, and recording the space capacity as a cache space capacity value;
starting a hash learning lookup module: starting to respond to engine access, and initiating a locking request to the hash address searched by the hash learning;
an address conflict determination module: judging whether the hash address searched by the hash learning has address conflict or not to obtain a conflict judgment result;
and the end Hash learning search module: and initiating an unlocking request to the hash address searched by the hash learning according to the conflict judgment result.
Preferably, the address conflict determination module includes:
an address comparison module: comparing the hash address searched by the hash learning with the address in the hash locking address buffer space, if the hash address searched by the hash learning has the same address as the address in the hash locking address buffer space, recording the result as a first comparison result, and if the hash address searched by the hash learning does not have the same address as the address in the hash locking address buffer space, recording the result as a second comparison result;
an engine shielding module: if a first comparison result is obtained after the address comparison, the locking request is shielded, the shielded address is marked as a first shielded address, the first shielded address is added into a shielded address set, and a shielded engine, a shielded address and engine initiation request time are stored in the shielded address set;
an engine response module: and responding to the locking request if a second comparison result is obtained after the address comparison.
Preferably, the system for solving the hash lookup learning and address aging conflicts of the multiple microengines further comprises a cache space judgment module;
a buffer space determination module: the method comprises the steps of calculating the space capacity of a Hash locking address buffer space, obtaining a first space capacity, comparing the first space capacity with a cache space capacity value, judging that the Hash locking address buffer space has a vacant space if the first space capacity is smaller than the cache space capacity value, and judging that the Hash locking address buffer space has no vacant space if the first space capacity is equal to the cache space capacity value.
Preferably, the system for solving the hash search learning and address aging conflicts of the multiple microengines further comprises an address unlocking module;
an address unlocking module: and comparing the unlocked address with the shielded address in the shielded address set, responding to an engine corresponding to the shielded address if the unlocked address is the same as the shielded address in the shielded address set, deleting the unlocked address from the hash locking address cache space if the unlocked address is not the same as the shielded address in the shielded address set, and responding to the shielded engine in the shielded address set.
According to the present invention, a computer-readable storage medium is provided, in which a computer program is stored, which, when being executed by a processor, carries out the steps of the method as described above.
Compared with the prior art, the invention has the following beneficial effects:
1. a buffer space of a hash locking address is maintained, address locking protection is achieved, the address is only opened for searching or learning or aging operation of a certain micro-engine, and MEM operation during hash address collision is solved.
2. When the same address is written back for multiple times, the previous written back content is automatically reserved, and the same address is correctly written for multiple times in one engine cycle.
Drawings
Other features, objects and advantages of the invention will become more apparent upon reading of the detailed description of non-limiting embodiments with reference to the following drawings:
FIG. 1 is a locking code state machine of an embodiment of the present invention;
fig. 2 is an unlock code state machine according to an embodiment of the present invention.
Detailed Description
The present invention will be described in detail with reference to specific examples. The following examples will assist those skilled in the art in further understanding the invention, but are not intended to limit the invention in any way. It should be noted that it would be obvious to those skilled in the art that various changes and modifications can be made without departing from the spirit of the invention. All falling within the scope of the present invention.
The invention discloses a method for solving hash search learning and address aging conflicts of multiple microengines, which comprises the following steps of: establishing a Hash locking address cache space: creating and maintaining a hash locking address cache space, setting space capacity for the hash locking address cache space, and recording the space capacity as a cache space capacity value; starting a Hash learning search step: starting to respond to engine access, and initiating a locking request to the hash address searched by the hash learning; an address conflict judging step: judging whether address conflict exists in the hash addresses searched by the hash learning; and finishing the Hash learning search step: and initiating an unlocking request to the hash address searched by the hash learning.
Specifically, the address conflict determining step includes: and an address comparison step: comparing the hash address searched by the hash learning with the address in the hash locking address buffer space, if the hash address searched by the hash learning has the same address as the address in the hash locking address buffer space, recording the result as a first comparison result, and if the hash address searched by the hash learning does not have the same address as the address in the hash locking address buffer space, recording the result as a second comparison result; an engine shielding step: if a first comparison result is obtained after the address comparison, the locking request is shielded, the shielded address is marked as a first shielded address, the first shielded address is added into a shielded address set, and a shielded engine, a shielded address and engine initiation request time are stored in the shielded address set; an engine response step: and responding to the locking request if a second comparison result is obtained after the address comparison.
Specifically, the method for solving the hash lookup learning and address aging conflict of the multiple microengines further comprises a cache space judgment step; a cache space judgment step: the method comprises the steps of calculating the space capacity of a Hash locking address buffer space, obtaining a first space capacity, comparing the first space capacity with a cache space capacity value, judging that the Hash locking address buffer space has a vacant space if the first space capacity is smaller than the cache space capacity value, and judging that the Hash locking address buffer space has no vacant space if the first space capacity is equal to the cache space capacity value.
Specifically, the method for solving the hash search learning and address aging conflict of the multiple microengines further comprises an address unlocking step; and (3) address unlocking: and comparing the unlocked address with the shielded address in the shielded address set, responding to an engine corresponding to the shielded address if the unlocked address is the same as the shielded address in the shielded address set, deleting the unlocked address from the hash locking address cache space if the unlocked address is not the same as the shielded address in the shielded address set, and responding to the shielded engine in the shielded address set.
The invention also discloses a system for solving the Hash search learning and address aging conflict of the multiple microengines, which comprises the following modules: establishing a Hash locking address cache space module: creating and maintaining a hash locking address cache space, setting space capacity for the hash locking address cache space, and recording the space capacity as a cache space capacity value; starting a hash learning lookup module: starting to respond to engine access, and initiating a locking request to the hash address searched by the hash learning; an address conflict determination module: judging whether address conflict exists in the hash addresses searched by the hash learning; and the end Hash learning search module: and initiating an unlocking request to the hash address searched by the hash learning.
Specifically, the address conflict determination module includes: an address comparison module: comparing the hash address searched by the hash learning with the address in the hash locking address buffer space, if the hash address searched by the hash learning has the same address as the address in the hash locking address buffer space, recording the result as a first comparison result, and if the hash address searched by the hash learning does not have the same address as the address in the hash locking address buffer space, recording the result as a second comparison result; an engine shielding module: if a first comparison result is obtained after the address comparison, the locking request is shielded, the shielded address is marked as a first shielded address, the first shielded address is added into a shielded address set, and a shielded engine, a shielded address and engine initiation request time are stored in the shielded address set; an engine response module: and responding to the locking request if a second comparison result is obtained after the address comparison.
Specifically, the system for solving the hash search learning and address aging conflicts of the multiple microengines further comprises a cache space judgment module; a buffer space determination module: the method comprises the steps of calculating the space capacity of a Hash locking address buffer space, obtaining a first space capacity, comparing the first space capacity with a cache space capacity value, judging that the Hash locking address buffer space has a vacant space if the first space capacity is smaller than the cache space capacity value, and judging that the Hash locking address buffer space has no vacant space if the first space capacity is equal to the cache space capacity value.
Specifically, the system for solving the hash search learning and address aging conflict of the multiple microengines further comprises an address unlocking module; an address unlocking module: and comparing the unlocked address with the shielded address in the shielded address set, responding to an engine corresponding to the shielded address if the unlocked address is the same as the shielded address in the shielded address set, deleting the unlocked address from the hash locking address cache space if the unlocked address is not the same as the shielded address in the shielded address set, and responding to the shielded engine in the shielded address set.
The system for solving the Hash search learning and address aging conflict of the multi-micro-engine can be realized by the steps and flows of the method for solving the Hash search learning and address aging conflict of the multi-micro-engine. The method for solving the hash lookup learning and address aging conflict of the multi-micro engine can be understood as a preferred example of the system for solving the hash lookup learning and address aging conflict of the multi-micro engine by those skilled in the art.
The invention also discloses a computer-readable storage medium storing a computer program which, when executed by a processor, implements the steps of the above-described method.
The invention is further illustrated below.
The invention firstly maintains a buffer space of the hash locking address, and the space size is the maximum number of hash searching and learning which can be processed by an engine at the same time. Although not only the hash addr is processed in the search and learning, but the hash addr is actually based on the hash addr, so as long as the hash addr has the condition of simultaneous access, the subsequent processing can have the condition of simultaneous access. There is an arbitration module for both internal and external mems, since some hash addr is present in the external mem.
And in the starting state of hash learning and searching, a locking request is initiated, and the processed hash address is used for judging whether the hash address is processed by a search engine at the same time. Specifically, whether the address stored in the current locking address buffer space has a hash address to be locked currently is compared, and if yes, the request of the current engine is directly shielded; if the request does not exist, responding to the request of the current engine, and locking the hash address of the current request, namely storing the hash address into a locked address buffer space; if the current locked address buffer space has no free space, directly shielding the access of the engine until the buffer has space, and continuing to judge.
When the hash learning and searching are in the ending state, initiating an unlocking request, judging the unlocked hash address of the unlocking request and the current shielded address, and if the unlocked hash address is the same as the current shielded address, cancelling a shielding signal and responding to a shielded engine; if the same address does not exist, deleting the corresponding address of the locking buffer space, and if the current request is shielded, selecting a response with early initiation time (judging by using frame id to find out the minimum frame id), and putting the corresponding hash address into the locking buffer space.
Taking verilog hardware code implementation as an example, those skilled in the art may also use other programming languages to implement the method, where the implementation scheme includes a module for finding the minimum value from the data of 32 and a module for extracting the ID number of the corresponding minimum value from the data ratio of 32. The memory locking is mainly used for the access arbitration of 32 search engines to the memory, and the problem of simultaneous access to the same address mentioned before is considered during the arbitration.
In a particular embodiment, as shown in FIG. 1, the locking code state machine has transitions in the IDLE, HAVE _ SPACE, CONFLICTS, BLOCK _ REQ, TARNSMIT, NO _ SPACE states, respectively. The state IDLE shows that locking processing is not needed at present, and the state is jumped out if any engine has an access request of a hash table; the state HAVE SPACE is used to determine if there is room in the cache currently used to store the locked address. If the address needs to be unlocked currently, the operation of unlocking the address is firstly processed, and the terminal waits in the state; if the address does not need to be unlocked currently, continuously judging whether the buffer has SPACE, and if the buffer does not have SPACE, entering a state NO _ SPACE; if the space exists, entering a state CONFLIC; the state CONFLICTS is used for judging whether a page address needing to be accessed currently is accessed by other search engines. If yes, entering a BLOCK _ REQ state; if not, entering a TRANSMIT state. However, if the address needs to be unlocked currently, the operation of unlocking the address is processed first, and the state is waited for; the state BLOCK _ REQ finds the address of the current engine hash request, which has been previously accessed by the engine and has not yet finished. At this point, in this state, the engine's access is masked and the next state IDLE is entered; the state TARNSMIT is that the hash request address of the current engine is judged, no engine accesses before, the request is directly responded at the moment, and the request address is put into the buffer of the locking address; NO _ SPACE: this state is where it has been determined that there is no more room for buffering of the locked address, at which point the current request is masked and the IDLE state is entered.
As shown in fig. 2, in a specific embodiment, the unlock code STATE machine has transitions to IDLE _ U, UNLOCK _ STATE, respectively. The state IDLE _ U is an unlock waiting state. Only when there is an address currently needing to be unlocked and no other requests are being processed, the STATE is popped out to UNLOCK _ STATE; the STATE UNLOCK _ STATE is an UNLOCK processing STATE, and is tripped out only when a signal identifying completion of the UNLOCK processing is valid.
Those skilled in the art will appreciate that, in addition to implementing the systems, apparatus, and various modules thereof provided by the present invention in purely computer readable program code, the same procedures can be implemented entirely by logically programming method steps such that the systems, apparatus, and various modules thereof are provided in the form of logic gates, switches, application specific integrated circuits, programmable logic controllers, embedded microcontrollers and the like. Therefore, the system, the device and the modules thereof provided by the present invention can be considered as a hardware component, and the modules included in the system, the device and the modules thereof for implementing various programs can also be considered as structures in the hardware component; modules for performing various functions may also be considered to be both software programs for performing the methods and structures within hardware components.
The foregoing description of specific embodiments of the present invention has been presented. It is to be understood that the present invention is not limited to the specific embodiments described above, and that various changes or modifications may be made by one skilled in the art within the scope of the appended claims without departing from the spirit of the invention. The embodiments and features of the embodiments of the present application may be combined with each other arbitrarily without conflict.
Claims (5)
1. A method for solving hash search learning and address aging conflicts of multiple microengines is characterized by comprising the following steps:
establishing a Hash locking address cache space: creating and maintaining a hash locking address cache space, setting space capacity for the hash locking address cache space, and recording the space capacity as a cache space capacity value;
starting a Hash learning search step: starting to respond to engine access, and initiating a locking request to the hash address searched by the hash learning;
an address conflict judging step: judging whether the hash address searched by the hash learning has address conflict or not to obtain a conflict judgment result;
and finishing the Hash learning search step: according to the collision judgment result, initiating an unlocking request to the hash address searched by the hash learning;
the address conflict determination step includes:
and an address comparison step: comparing the hash address searched by the hash learning with the address in the hash locking address buffer space, if the hash address searched by the hash learning has the same address as the address in the hash locking address buffer space, recording the result as a first comparison result, and if the hash address searched by the hash learning does not have the same address as the address in the hash locking address buffer space, recording the result as a second comparison result;
an engine shielding step: if a first comparison result is obtained after the address comparison, the locking request is shielded, the shielded address is recorded as a first shielded address, the first shielded address is added into a shielded address set, and a shielded engine, a shielded address and engine initiation request time are stored in the shielded address set;
an engine response step: if a second comparison result is obtained after the address comparison, responding to the locking request;
also includes the step of judging the buffer space;
a cache space judgment step: calculating the actual space capacity of the Hash locking address buffer space, obtaining a first space capacity, comparing the first space capacity with the capacity value of the cache space, if the first space capacity is smaller than the capacity value of the cache space, judging that the Hash locking address buffer space has a vacant space, and if the first space capacity is equal to the capacity value of the cache space, judging that the Hash locking address buffer space has no vacant space.
2. The method for resolving hash lookup learning and address aging conflicts for multiple microengines of claim 1, further comprising an address unlocking step;
and (3) address unlocking: and comparing the unlocked address with the shielded address in the shielded address set, responding to an engine corresponding to the shielded address if the unlocked address is the same as the shielded address in the shielded address set, deleting the unlocked address from the hash locking address cache space if the unlocked address is not the same as the shielded address in the shielded address set, and responding to the shielded engine in the shielded address set.
3. A system for solving hash lookup learning and address aging conflicts of multiple microengines is characterized by comprising the following modules:
establishing a Hash locking address cache space module: creating and maintaining a hash locking address cache space, setting space capacity for the hash locking address cache space, and recording the space capacity as a cache space capacity value;
starting a hash learning lookup module: starting to respond to engine access, and initiating a locking request to the hash address searched by the hash learning;
an address conflict determination module: judging whether the hash address searched by the hash learning has address conflict or not to obtain a conflict judgment result;
and the end Hash learning search module: according to the conflict judgment result, initiating an unlocking request to the hash address searched by the hash learning;
the address conflict determination module comprises:
an address comparison module: comparing the hash address searched by the hash learning with the address in the hash locking address buffer space, if the hash address searched by the hash learning has the same address as the address in the hash locking address buffer space, recording the result as a first comparison result, and if the hash address searched by the hash learning does not have the same address as the address in the hash locking address buffer space, recording the result as a second comparison result;
an engine shielding module: if a first comparison result is obtained after the address comparison, the locking request is shielded, the shielded address is recorded as a first shielded address, the first shielded address is added into a shielded address set, and a shielded engine, a shielded address and engine initiation request time are stored in the shielded address set;
an engine response module: if a second comparison result is obtained after the address comparison, responding to the locking request;
the device also comprises a cache space judgment module;
a buffer space determination module: calculating the actual space capacity of the Hash locking address buffer space, obtaining a first space capacity, comparing the first space capacity with the capacity value of the cache space, if the first space capacity is smaller than the capacity value of the cache space, judging that the Hash locking address buffer space has a vacant space, and if the first space capacity is equal to the capacity value of the cache space, judging that the Hash locking address buffer space has no vacant space.
4. The system for resolving hash lookup learning and address aging conflicts for multiple microengines of claim 3, further comprising an address unlocking module;
an address unlocking module: and comparing the unlocked address with the shielded address in the shielded address set, responding to an engine corresponding to the shielded address if the unlocked address is the same as the shielded address in the shielded address set, deleting the unlocked address from the hash locking address cache space if the unlocked address is not the same as the shielded address in the shielded address set, and responding to the shielded engine in the shielded address set.
5. A computer-readable storage medium, in which a computer program is stored which, when being executed by a processor, carries out the steps of the method of any one of claims 1 to 2.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201811012989.2A CN109376097B (en) | 2018-08-31 | 2018-08-31 | Method for solving hash search learning and address aging conflict of multiple microengines |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201811012989.2A CN109376097B (en) | 2018-08-31 | 2018-08-31 | Method for solving hash search learning and address aging conflict of multiple microengines |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN109376097A CN109376097A (en) | 2019-02-22 |
| CN109376097B true CN109376097B (en) | 2021-05-07 |
Family
ID=65404384
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN201811012989.2A Active CN109376097B (en) | 2018-08-31 | 2018-08-31 | Method for solving hash search learning and address aging conflict of multiple microengines |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN109376097B (en) |
Families Citing this family (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN111858075A (en) * | 2020-06-30 | 2020-10-30 | 广东浪潮大数据研究有限公司 | Deadlock detection method, system, equipment and readable storage medium |
Family Cites Families (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN102486753B (en) * | 2009-11-30 | 2015-09-16 | 国际商业机器公司 | Build and allow the method for access cache, equipment and storage system |
| US20110276744A1 (en) * | 2010-05-05 | 2011-11-10 | Microsoft Corporation | Flash memory cache including for use with persistent key-value store |
| CN104461400B (en) * | 2014-12-25 | 2017-09-19 | 浪潮(北京)电子信息产业有限公司 | The method and apparatus for handling access request conflict |
| CN105528181B (en) * | 2015-12-04 | 2019-05-10 | 浪潮(北京)电子信息产业有限公司 | A kind of method of data IO hash |
-
2018
- 2018-08-31 CN CN201811012989.2A patent/CN109376097B/en active Active
Also Published As
| Publication number | Publication date |
|---|---|
| CN109376097A (en) | 2019-02-22 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN108234641B (en) | Data reading and writing method and device based on distributed consistency protocol | |
| US9871727B2 (en) | Routing lookup method and device and method for constructing B-tree structure | |
| US20150113230A1 (en) | Directory storage method and query method, and node controller | |
| US20150143065A1 (en) | Data Processing Method and Apparatus, and Shared Storage Device | |
| WO2011079748A1 (en) | Method and system for creating linked list, method and system for searching data | |
| CN108572876B (en) | Method and device for realizing read-write lock | |
| CA3151383A1 (en) | Method of and device for enquiring, by pagination, sub-tables divided from database, and computer equipment | |
| CN104268012B (en) | A kind of image data processing method and processing device | |
| CN112579595A (en) | Data processing method and device, electronic equipment and readable storage medium | |
| US9063667B2 (en) | Dynamic memory relocation | |
| US20160132559A1 (en) | Tcam-based table query processing method and apparatus | |
| CN109376097B (en) | Method for solving hash search learning and address aging conflict of multiple microengines | |
| CN116501249A (en) | Method for reducing repeated data read-write of GPU memory and related equipment | |
| CN109992526A (en) | A kind of read-write management method and relevant apparatus | |
| CN115114042A (en) | Storage data access method and device, electronic equipment and storage medium | |
| WO2019011311A1 (en) | Data access method and apparatus | |
| CN111221823B (en) | Data processing method and device based on link management table | |
| US20170300255A1 (en) | Method and Apparatus for Detecting Transaction Conflict and Computer System | |
| CN110334034B (en) | Mapping table dynamic loading method and device, computer equipment and storage medium | |
| CN117215491A (en) | Rapid data access method, rapid data access device and optical module | |
| CN110737678A (en) | data searching method, device, equipment and storage medium | |
| CN110909012B (en) | Method, device, equipment and storage medium for blocking database object | |
| US9063858B2 (en) | Multi-core system and method for data consistency by memory mapping address (ADB) to hash table pattern associated with at least one core | |
| CN112068948B (en) | Data hashing method, readable storage medium and electronic device | |
| CN110716814B (en) | Performance optimization method and device for inter-process large-data-volume communication |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant |