WO2015035891A1

WO2015035891A1 - Patching method, device, and system

Info

Publication number: WO2015035891A1
Application number: PCT/CN2014/086042
Authority: WO
Inventors: 王工艺; 李涛; 李生
Original assignee: 华为技术有限公司
Priority date: 2013-09-16
Filing date: 2014-09-05
Publication date: 2015-03-19
Also published as: CN103488505B; CN103488505A

Abstract

A patching method, device, and system. Said method comprises: if there is an error when the protocol engine in a node controller implements a cache coherence protocol, then suspending the error message and continuing to process the subsequent messages having addresses different from that of the error message, and an added patch receiving a lookup table data structure, catalog information, and error message, which are all sent by the node controller; the added patch module executes a patch process according to the lookup table data structure, catalog information, and error message; the patch process is used in place of the protocol engine to process the error message and generate a new message and generate corresponding new catalog information. By means of adding a patch module, when an error occurs, the protocol engine module suspends the error message and continues processing the subsequent messages, while the error message is processed by the patch module; thus when a protocol error occurs, the system is still guaranteed to operate normally.

Description

Patch method, device and system

The present application claims priority to Chinese Patent Application No. 20131042169 7.5, filed on Sep.

Technical field

The present application relates to the field of storage, and in particular to a patch method, device and system.

Background technique

With the rapid development of various terminals, various advanced applications are becoming more and more abundant, and the requirements for the operation speed of a central processing unit (CPU) are also increasing. However, the performance improvement of a single CPU is limited, and therefore, the multiprocessor system has been developed at a high speed. As shown in FIG. 1, a cache coherence protocol Non-Uniform Memory Access (CC-NUMA) multiprocessor system includes a plurality of CPUs 110 and a plurality of node controllers (Node Controller, NC). ) 120. The node controller 120 and the CPU 110 are topologically connected, and the node controller 120 coordinates the work between the plurality of CPUs 110.

Since each CPU 110 has at least one private cache buffer (Cache), all CPUs share a main memory. When different CPUs 110 use the same data to the main memory, the CPUs 110 respectively put the data into their own private cache and modify the data according to their respective needs, when one of the CPUs 110 is modified. At the time of this data, the other CPU 110 does not know that the existing CPU 110 has modified this data, and it is still processed according to the original data, causing a conflict, which leads to a Cache consistency problem.

The prior art provides a Cache coherency protocol, and at least one protocol processing engine is set in each node controller 120. When the packet enters the protocol processing engine, the protocol processing engine records the packet according to the type and directory information of the packet. The directory status is found in the corresponding protocol table, where the protocol table records the processing mode of the current message, the operation mode of the directory information, and whether conflicts occur. If a conflict occurs, the protocol processing engine processes the current packet according to the processing mode of the current packet and the operation mode of the directory information, and obtains new packets and updated directory information, thereby avoiding the Cache consistency problem.

However, the rapid expansion of system scale, network latency uncertainty and storage consistency models Many factors, such as modality, make the Cache coherence protocol extremely complex, and the state space of the protocol grows exponentially. Under the existing technical conditions, the Cache coherence protocol cannot cover all situations, that is, all conflicts can be solved. If there is a conflict that cannot be resolved, the protocol will be in a problem, and the protocol processing engine will not be able to process the current packet, and the subsequent packets will not be processed, resulting in the system not working properly.

Summary of the invention

The application provides a protocol processing engine fault tolerance processing method, device and system, which can ensure the normal operation of the system when the protocol is in error.

A first aspect of the present application provides a patching method, if a protocol processing engine in a node controller performs an Cache Coherency Protocol error, suspends an error message, and continues to process subsequent packets different from the error packet address, The patch receives the lookup table data structure, the directory information, and the error message sent by the node controller; the added patch module executes the patch according to the table lookup data structure, the directory information, and the error message The patch is configured to process the error message in place of the protocol processing engine to generate a new message and generate corresponding new directory information.

In conjunction with the first aspect, in a first possible implementation manner of the first aspect, the error message includes a current error message and a message having the same address as the current error message.

With reference to the first aspect, in a second possible implementation manner of the first aspect of the present application, the added patch module is configured to perform a patch procedure according to the table lookup data structure, the directory information, and the error message. The method further includes: the added patch module receives the lookup table data structure, the directory information, the error message, and the identifier of the protocol table that needs to be queried sent by the node controller.

The second aspect of the present application provides a node controller, including a patch module, where the patch module is coupled to a protocol processing engine module in a node controller, where the patch module includes: a receiving unit, and an executing unit, where the receiving unit is used by the receiving unit When the protocol processing engine module in the node controller executes the Cache coherency protocol error, suspends the error message, and continues to process subsequent messages different from the error message address, the table data sent by the node controller is received. a structure, directory information, and the error message, the receiving unit sends the lookup table data structure, the directory information, and the error message to the execution unit; the execution unit is configured to receive the check a table data structure, the directory information, and the error message, executing a patch according to the lookup table data structure, the directory information, and the error message, wherein the patch is used instead of the protocol processing The engine module enters the error message Line processing to generate new messages and generate corresponding new directory information.

In conjunction with the second aspect, in a first possible implementation manner of the second aspect, the error message includes a current error message and a message having the same address as the current error message.

With reference to the second aspect, in a second possible implementation manner of the second aspect of the present application, the receiving unit is further configured to receive a table lookup data structure, directory information, the error packet, and a query that are sent by the node controller. The identity of the agreement table.

A third aspect of the present application provides a patch system, including a patch module and a node controller, where the patch module is coupled to a protocol processing engine module in a node controller, where the node controller is configured to execute a Cache coherency protocol in a protocol processing engine. When an error occurs, the error message is suspended and the subsequent message different from the error message address is processed; the patch module is configured to receive the table lookup data structure, the directory information, and the error message sent by the node controller. And executing a patch according to the lookup table data structure, the directory information, and the error message, wherein the patch is used to replace the error processing message by the protocol processing engine to generate a new report. And generate corresponding new directory information.

In conjunction with the third aspect, in a first possible implementation manner of the third aspect, the error message includes a current error message and a message having the same address as the current error message.

With reference to the third aspect, in a second possible implementation manner of the third aspect, the patch module is further configured to receive a table lookup data structure, directory information, the error packet, and a query that are sent by the node controller. The identity of the agreement table.

In conjunction with the third aspect, in a third possible implementation manner of the third aspect of the present application, the patch module includes an input random access memory, a patch processor, and an output random access memory, wherein the input random access memory One end is coupled to one end of the protocol processing engine module in the node controller, and the other end is coupled to one end of the patch processor, and the other end of the patch processor is coupled to one end of the output random access memory, the output The other end of the random access memory is coupled to the other end of the protocol processing engine in the node controller, where the input random access memory is used to store the table lookup data structure, the directory information, and the error message sent by the node controller. The patch processor is configured to use the lookup table data structure, the directory information, and the error message execution patch, where the patch is used to process the error message instead of the protocol processing engine. Generating a new message and generating corresponding new directory information; the output random access memory is used to store new messages and Directory information.

In conjunction with the third possible implementation of the third aspect, the fourth possible aspect of the third aspect of the present application In an embodiment, the number of the input random access memory and the output random access memory are the same as the number of the protocol processing engines, wherein one end of one of the input random access memories is coupled to a protocol processing At one end of the engine, the other end of all the input random access memories is coupled to the patch processor, and the other end of the patch processor is coupled to one end of all the output random access memories, and the other end of each output random access memory. The other end of a protocol processing engine module is coupled to each other.

The above application is added with a patch module. When the protocol processing engine is faulty, the protocol processing engine suspends the error message, and continues to process subsequent messages with different error message addresses, and the error packets are processed by the patch module. To ensure that the system will still work properly in the event of a protocol error.

DRAWINGS

1 is a schematic structural view of an embodiment of a prior art multiprocessing system;

2 is a schematic structural diagram of an embodiment of a patch system of the present application;

3 is a flowchart of an embodiment of a patching method of the present application;

4 is a schematic structural diagram of an embodiment of a node controller according to the present application;

FIG. 5 is a schematic structural diagram of another embodiment of a node controller according to the present application.

detailed description

In the following description, for purposes of illustration and description, reference However, it will be apparent to those skilled in the art that the present invention can be implemented in other embodiments without these specific details. In other instances, detailed descriptions of well-known devices, circuits, and methods are omitted so as not to obscure the description of the application.

Referring to FIG. 2, FIG. 2 is a schematic structural diagram of an embodiment of a patch system of the present application. The patch system of this embodiment includes a patch module 210 and a node controller 220. The patch module 210 and the node controller 220 collectively schedule a plurality of CPUs. The patch module 210 includes a plurality of input random access memories 211, a patch processor 213, and a plurality of output random access memories 215. The node controller 220 includes a plurality of protocol processing engines 221 and a plurality of protocol table (P-Table) memories 223. Moreover, the numbers of the input random access memory 211, the output random access memory 215, the protocol processing engine 221, and the protocol table memory 223 are all equal.

One end of the input random access memory 211 is coupled to one end of a protocol processing engine 221. The other end of the input random access memory 211 is coupled to the patch processor 213. The other end of the patch processor 213 is coupled to all the outputs at the same time. One end of the memory 215 is accessed, and the other end of each output random access memory 215 is coupled to the other end of a protocol processing engine 221. Each protocol processing engine 221 is coupled to a protocol table memory 223.

When the message is processed by the protocol processing engine 221, the protocol processing engine 221 reads the protocol in the protocol table memory 223 according to the type of the message and the current directory status. The protocol in the protocol table memory 223 includes the processing mode of the message. How the directory operates, how internal entries work, and whether the protocol is in error. If the protocol design is incomplete, the packet will be processed according to the protocol, and the result will be incorrect. If the protocol cannot process the packet, the protocol will be faulty, and the packet that cannot be processed is an error packet. If there is no error in the protocol, the packet is processed by the Cache coherence protocol according to the protocol, so that a new packet is obtained and a new directory is generated, and the new packet is added to the pipeline.

When a protocol processing engine 221 performs a Cache coherency protocol error, the protocol processing engine module 221 suspends the error message to suspend processing of the message, including the current error message and the same message as the current error message address, since each Each message has a corresponding address, so it is easy to find the above message, where the address refers to the system address of the CPU, and the table data structure, the directory information, and the error message are sent to the protocol processing engine 221. The random access memory 211 is input. The lookup table data structure is used to record environmental data including the error message address, whether it is in the conflict processing stage, whether it is in the write operation phase, and whether the error message is suspended due to the conflict. The directory information includes pointers and states for pointing to an address space in the processor for indicating the specific state of the address space of the processor to which the pointer points, including exclusive, shared, and invalid. For example, before an error occurs, an address space of a controller is being accessed, the pointer points to the address space, and the status item records the specific state of the address space. The lookup table data structure records the environmental data when accessing this address space.

In another embodiment, the lookup table data structure includes a plurality of field definitions, the field definitions for recording the status of the transaction, including the address of the message, the target ID number, whether it is in the conflict processing stage, and whether it is in a write operation. Stage, whether to suspend the message because of the conflict. When a patch needs to be run, the transaction is in an intermediate state, and the patch knows the intermediate state to achieve correct packet processing. At the same time, after the patch is processed, the intermediate state output needs to be saved and saved for use in the next transaction. Of course, after the final transaction is completed, the data structure will be automatically cleared.

If the processor has enough information to process the message, it does not need to continue to query the protocol table. If the processor does not have enough information to process the message, it needs to continue to query the protocol table. If it is still necessary to continue to query the protocol table, the identifier of the protocol table that needs to be queried may be sent together with the lookup table data structure, the directory information, and the error message to the input random access memory 211 corresponding to the protocol processing engine module 221. The protocol processing engine 221 continues to process subsequent messages that are different from the error message address to avoid clogging.

When the patch processor 213 detects that there is an error message to be processed in the input random access memory 211, the table data structure, the directory information, and the error message are read from the input random access memory 211, and according to the table data structure. The directory information and the error message execution patch, wherein the patch is used to replace the protocol processing engine 221 to process the error message according to the original processing mode of the protocol processing engine to generate a new message and generate corresponding new directory information. . If the protocol table needs to be further queried, the patch processor 213 queries the protocol table according to the identifier of the protocol table that needs to be queried, and then executes a patch according to the data structure, the directory information, and the error message to generate a new packet and generate a corresponding packet. New directory information. For example, the patch can restore the operation of the address space according to the lookup table data structure, and obtain the state of the address space from the directory information. Therefore, the patch can replace the protocol processing engine 221 to process the original error of the error message according to the protocol processing engine. The processing mode is processed, and a new packet is generated. After the processing is completed, the state of the address space may be changed, and the directory information is updated to generate new directory information.

The patch processor 213 writes the new message and the new directory information to the output random access memory 215 corresponding to the protocol processing engine module 221, wherein each protocol processing engine module 221 and one output random access memory 215 connection. After the protocol processing engine 221 detects that there is a new message in the corresponding output random access memory 215, the new message is inserted into the second half of the pipeline. Among them, the order of the messages constitutes a pipeline.

If the other protocol processing engine 221 fails in executing the protocol, it is also processed in accordance with the above method.

In the present embodiment, each protocol processing engine 221 is respectively provided with an input random access memory 211 and an output random access memory 215, and a plurality of input random access memories 211 and a plurality of output random access memories 215. A patch processor 213 is shared. In the case where the error rate of the protocol processing engine 221 is relatively low when the protocol is executed, the plurality of protocol processing engines 221 may share one input random access memory 211, one output random access memory 215, and one. Patch processor 213. Conversely, if the requirements are relatively high, a protocol processing engine 221 can also use an input random access memory 211, an output random access memory 215, and a patch processor 213.

Referring to FIG. 3, FIG. 3 is a flowchart of an embodiment of a patching method of the present application. The patch method of this embodiment includes the following steps:

S301: If the protocol processing engine in the node controller performs a Cache coherency protocol error, suspends the error message, and continues to process subsequent messages different from the error message address, the added patch receives the lookup table sent by the node controller. Data structure, directory information, and error messages.

When a protocol processing engine module in the node controller performs a Cache coherency protocol error, the protocol processing engine module suspends the error message to suspend processing of the message, including the current error message and the same message as the current error message address. Therefore, since each message has a corresponding address, it is easy to find the above message, where the address refers to the system address of the CPU, and the data structure, directory information, and error message of the lookup table are sent to the patch. The lookup table data structure is used to record environmental data including the error message address, whether it is in the conflict processing stage, whether it is in the write operation phase, and whether the error message is suspended due to the conflict. The directory information includes pointers and states for pointing to an address space in the processor for indicating the specific state of the address space of the processor to which the pointer points, including exclusive, shared, and invalid. For example, before an error occurs, an address space of a controller is being accessed, the pointer points to the address space, and the status item records the specific state of the address space. The lookup table data structure records the environmental data when accessing this address space.

In another embodiment, the lookup table data structure includes a plurality of field definitions, the field definitions for recording the status of the transaction, including the address of the message, the target ID number, whether it is in the conflict processing stage, and whether it is in a write operation. Stage, whether to suspend the message because of the conflict. When a patch needs to be run, the transaction is in an intermediate state, and the patch knows the intermediate state to achieve correct packet processing. At the same time, after the patch is processed, the intermediate state output needs to be saved and saved for use in the next transaction. Of course, after the final transaction is completed, the data structure is automatically cleared.

If the processor has enough information to process the message, it does not need to continue to query the protocol table. If the processor does not have enough information to process the message, it needs to continue to query the protocol table. If you need to continue to query the protocol table, you can send the identifier of the protocol table to be queried together with the table data structure, directory information, and error packets to the patch module. The protocol processing engine continues to process subsequent messages that are different from the error message address to avoid clogging.

The added patch corresponds to the lookup table data structure, directory information, and error packets sent by the node controller. If the protocol table needs to be queried, the patch module receives the data structure of the lookup table, the directory information, the error packet, and the identifier of the protocol table to be queried.

S302: The added patch module executes a patch according to the lookup table data structure, the directory information, and the error message, where the patch is used to replace the protocol processing engine to process an error message to generate New messages and corresponding new directory information.

When the added patch module detects an error message that needs to be processed, the data structure, the directory information, and the error message are input, and the patch is executed according to the data structure of the table, the directory information, and the error message. It is used to replace the protocol processing engine to process the error message according to the original processing mode of the protocol processing engine to generate a new message and generate corresponding new directory information. For example, the patch can restore the operation of the address space according to the lookup table data structure, and obtain the state of the address space from the directory information. Therefore, the patch can replace the protocol processing engine 221 to process the original error of the error message according to the protocol processing engine. The processing mode is processed, and a new packet is generated. After the processing is completed, the state of the address space may be changed, and the directory information is updated to generate new directory information.

If the protocol table needs to be further queried, the added patch queries the protocol table according to the identifier of the protocol table to be queried, and then executes a patch according to the data structure, the directory information, and the error message to generate a new packet and generate a corresponding packet. New directory information. The added patch inserts new messages and new directory information into the second half of the pipeline. Among them, the order of the messages constitutes a pipeline.

All of the methods described in this embodiment can be applied to the patch system described above and the node controller described below.

Referring to FIG. 4, FIG. 4 is a schematic structural diagram of an embodiment of a node controller according to the present application. The node controller of the present embodiment includes a patch module, and the patch module is coupled to a protocol processing engine module in the node controller, where the patch module includes: a receiving unit 410 and an executing unit 420.

The receiving unit 410 is configured to: when the protocol processing engine module in the node controller executes a Cache coherency protocol error, suspends the error message, and continues to process subsequent messages different from the error message address, the receiving node controller sends the check Table data structure, directory information, and error messages. For example, when a protocol processing engine module in the node controller executes the Cache coherency protocol error, the protocol processing engine module suspends the error message to suspend the processing of the message, including the current error message and the same as the current error message address. The message, because each message has a corresponding address, it is easy to find the above message, where the address refers to the system address of the CPU, and will look up the data structure, directory information and error messages. Send to the receiving unit 410. The lookup table data structure is used to record environmental data including the error message address, whether it is in the conflict processing stage, whether it is in the write operation phase, and whether the error message is suspended due to the conflict. The directory information includes pointers and states for pointing to an address space in the processor for indicating the specific state of the address space of the processor to which the pointer points, including exclusive, shared, and invalid. For example, before an error occurs, an address space of a controller is being accessed, the pointer points to the address space, and the status item records the specific state of the address space. The lookup table data structure records the environmental data when accessing this address space.

If the processor has enough information to process the message, it does not need to continue to query the protocol table. If the processor does not have enough information to process the message, it needs to continue to query the protocol table. If it is still necessary to continue to query the protocol table, the identifier of the protocol table that needs to be queried may be sent to the receiving unit 410 together with the lookup table data structure, the directory information, and the error message. The protocol processing engine module continues to process subsequent messages that are different from the error message address, thereby avoiding congestion.

The receiving unit 410 correspondingly receives the table lookup data structure, the directory information, and the error message sent by the node controller. If it is necessary to continue to query the protocol table, the receiving unit 410 correspondingly receives the table data structure, the directory information, the error message, and the identifier of the protocol table that needs to be queried.

The receiving unit 410 transmits the lookup table data structure, the directory information, and the error message to the execution unit 420.

The executing unit 420 is configured to receive the lookup table data structure, the directory information, and the error message, and execute the patch according to the table data structure, the directory information, and the error message, where the patch is used instead of the protocol processing engine module to report the error. The text is processed according to the original processing method of the protocol processing engine to generate a new message and generate corresponding new directory information.

When the execution unit 420 detects an error message that needs to be processed, it receives the table data structure, the directory information, and the error message, and executes the patch according to the table data structure, the directory information, and the error message, wherein the patch is used. Processing the error message instead of the protocol processing engine module to generate Create new messages and generate corresponding new directory information. If it is still necessary to continue to query the protocol table, the executing unit 420 queries the protocol table according to the identifier of the protocol table that needs to be queried, and then executes a patch according to the table data structure, the directory information, and the error message to generate a new packet and generate a corresponding packet. New directory information. For example, the patch can restore the operation of the address space according to the lookup table data structure, and obtain the state of the address space from the directory information. Therefore, the patch can replace the protocol processing engine 221 to process the original error of the error message according to the protocol processing engine. The processing mode is processed, and a new packet is generated. After the processing is completed, the state of the address space may be changed, and the directory information is updated to generate new directory information.

The execution unit 420 inserts the new message and the new directory information into the second half of the pipeline. Among them, the order of the messages constitutes a pipeline.

Referring to FIG. 5, FIG. 5 is a schematic structural diagram of another embodiment of a node controller according to the present application. The protocol processing engine fault tolerance processing apparatus of the present embodiment includes a patch module including an input random access memory 510, a patch processor 520, and an output random access memory 530. One end of the input random access memory 510 is coupled to the protocol processing engine module in the node controller, the other end of the input random access memory 510 is coupled to one end of the patch processor 520, and the other end of the patch processor 520 is coupled to the output. At one end of the random access memory 530, the other end of the output random access memory 530 is coupled to a protocol processing engine module within the node controller.

The input random access memory 510 is configured to: when the protocol processing engine module in the node controller executes a Cache coherency protocol error, suspends the error message, and continues to process subsequent messages different from the error message address, the receiving node controller The data structure of the table lookup, the directory information, and the error message. For example, when a protocol processing engine in the node controller executes the Cache coherency protocol error, the protocol processing engine suspends the error message to suspend the processing of the message, including the current error message and the same message as the current error message address. Since each message has a corresponding address, it is easy to find the above message, where the address refers to the system address of the CPU, and the data structure, directory information, and error message of the lookup table are sent to the input random access. Memory 510. The lookup table data structure is used to record environmental data including the error message address, whether it is in the conflict processing stage, whether it is in the write operation phase, and whether the error message is suspended due to the conflict. The directory information includes pointers and states for pointing to an address space in the processor for indicating the specific state of the address space of the processor to which the pointer points, including exclusive, shared, and invalid. For example, before an error occurs, an address space of a controller is being accessed, the pointer points to the address space, and the status item records the address empty. The specific state between. The lookup table data structure records the environmental data when accessing this address space.

If the processor has enough information to process the message, it does not need to continue to query the protocol table. If the processor does not have enough information to process the message, it needs to continue to query the protocol table. If it is still necessary to continue to query the protocol table, the identifier of the protocol table that needs to be queried may be sent to the input random access memory 510 together with the lookup table data structure, the directory information, and the error message. The protocol processing engine continues to process subsequent messages that are different from the error message address to avoid clogging.

The input random access memory 510 correspondingly receives the lookup table data structure, the directory information, and the error message sent by the node controller. If it is necessary to continue to query the protocol table, the input random access memory 510 correspondingly receives the table data structure, the directory information, the error message, and the identifier of the protocol table to be queried.

The patch processor 520 is configured to execute a patch according to the lookup table data structure, the directory information, and the error message, wherein the patch is used to replace the protocol processing engine to process the error message to generate a new message and generate a corresponding new one. Directory information. For example, when the patch processor 520 detects that the input random access memory 510 has an error message that needs to be processed, it receives the table data structure, the directory information, and the error message, and according to the table data structure, the directory information, and the error message. The patch is executed, wherein the patch is used to replace the protocol processing engine to process the error message according to the original processing mode of the protocol processing engine to generate a new message and generate corresponding new directory information. If it is still necessary to continue to query the protocol table, the patch processor 520 queries the protocol table according to the identifier of the protocol table that needs to be queried, and then executes a patch according to the table data structure, the directory information, and the error message to generate a new packet and generate a corresponding packet. New directory information. For example, the patch can restore the operation of the address space according to the lookup table data structure, and obtain the state of the address space from the directory information. Therefore, the patch can replace the protocol processing engine 221 to process the original error of the error message according to the protocol processing engine. The processing mode is processed, and a new packet is generated. After the processing is completed, the state of the address space may be changed, and the directory information is updated to generate new directory information. The patch processor 520 inserts the new message and the new directory information temporarily stored in the patch processor 520 into the second half of the pipeline. Among them, the order of the messages constitutes a pipeline.

The output random access memory 730 is used to temporarily store the new message output by the patch processor 720 and the new directory information.

The application also provides a protocol processing engine fault-tolerant processing system, including a patch module, and the patch module is coupled to a protocol processing engine module in the node controller. For a specific implementation, refer to FIG. 2 and related descriptions, and details are not repeated herein.

In the several embodiments provided in the present application, it should be understood that the disclosed system, apparatus, and method may be implemented in other manners. For example, the device implementations described above are merely illustrative. For example, the division of the modules or units is only a logical function division. In actual implementation, there may be another division manner, for example, multiple units or components may be used. Combinations can be integrated into another system, or some features can be ignored or not executed. In addition, the mutual coupling or direct coupling or communication connection shown or discussed may be an indirect coupling or communication connection through some interface, device or unit, and may be in an electrical, mechanical or other form.

The units described as separate components may or may not be physically separated, and the components displayed as units may or may not be physical units, that is, may be located in one place, or may be distributed to multiple network units. Some or all of the units may be selected according to actual needs to achieve the purpose of the solution of the present embodiment.

In addition, each functional unit in each embodiment of the present application may be integrated into one processing unit, or each unit may exist physically separately, or two or more units may be integrated into one unit. The above integrated unit can be implemented in the form of hardware or in the form of a software functional unit.

The integrated unit, if implemented in the form of a software functional unit and sold or used as a standalone product, may be stored in a computer readable storage medium. Based on such understanding, the technical solution of the present application, in essence or the contribution to the prior art, or all or part of the technical solution may be embodied in the form of a software product stored in a storage medium. Including a number of instructions for causing a computer device (which may be a personal computer, server, or network device, etc.) or a processor to perform various embodiments of the present application. All or part of the steps of the method. The foregoing storage medium includes: a U disk, a mobile hard disk, a read-only memory (ROM), a random access memory (RAM), a magnetic disk, or an optical disk, and the like. .

Claims

A patching method is characterized in that if a protocol processing engine in a node controller performs a Cache coherency protocol error, suspends an error message, and continues to process subsequent packets different from the error packet address, the added patch Receiving a table lookup data structure, directory information, and the error message sent by the node controller;

The added patch module executes a patch according to the lookup table data structure, the directory information, and the error message, wherein the patch is used to process the error message instead of the protocol processing engine. To generate new messages and generate corresponding new directory information.
The method according to claim 1, wherein the error message comprises a current error message and a message having the same address as the current error message.
The method according to claim 1, wherein the step of the patch module executing the patch according to the table lookup data structure, the directory information, and the error message further comprises: adding the added The patch module receives the lookup table data structure, the directory information, the error message, and the identifier of the protocol table that needs to be queried sent by the node controller.
A node controller, comprising: a patch module, wherein the patch module is coupled to a protocol processing engine module in a node controller, where the patch module comprises: a receiving unit and an executing unit,

The receiving unit is configured to: when the protocol processing engine module in the node controller executes a Cache coherency protocol error, suspends the error message, and continues to process subsequent messages different from the error message address, the receiving node controller The receiving table data structure, the directory information, and the error message, the receiving unit sends the table lookup data structure, the directory information, and the error message to the execution unit;

The execution unit is configured to receive the lookup table data structure, the directory information, and the error message, and execute a patch according to the table lookup data structure, the directory information, and the error message, where The patch is used to process the error message in place of the protocol processing engine module to generate a new message and generate corresponding new directory information.
The node controller according to claim 4, wherein the error message comprises a current error message and a message having the same address as the current error message.
The node controller according to claim 4, wherein the receiving unit is further configured to receive a table lookup data structure, directory information, the error message, and a request sent by the node controller. The identifier of the protocol table to be queried.
A patch system, comprising: a patch module and a node controller, wherein the patch module is coupled to a protocol processing engine in the node controller,

The node controller is configured to suspend an error message and continue to process subsequent messages different from the error message address when the protocol processing engine performs a Cache coherency protocol error;

The patch module is configured to receive a table lookup data structure, directory information, and the error packet sent by the node controller, and execute a patch according to the lookup table data structure, the directory information, and the error packet, where The patch is configured to process the error message in place of the protocol processing engine to generate a new message and generate corresponding new directory information.
The system of claim 7, wherein the error message comprises a current error message and a message having the same address as the current error message.
The system according to claim 7, wherein the patch module is further configured to receive a table lookup data structure, directory information, the error message, and an identifier of a protocol table that needs to be queried sent by the node controller.
The system of claim 7, wherein the patch module comprises an input random access memory, a patch processor, and an output random access memory, wherein one end of the input random access memory is coupled to the node controller One end of the protocol processing engine is coupled to one end of the patch processor, and the other end of the patch processor is coupled to one end of the output random access memory, and the other end of the output random access memory is coupled The other end of the protocol processing engine within the node controller,

The input random access memory is configured to store a table lookup data structure, directory information, and the error message sent by the node controller;

The patch processor is configured to use the lookup table data structure, the directory information, and the error message execution patch, where the patch is used to replace the error processing message by the protocol processing engine to process Generate new messages and generate corresponding new directory information;

The output random access memory is used to store new messages and new directory information.
The system according to claim 10, wherein the number of the input random access memory and the output random access memory are the same as the number of the protocol processing engines, wherein one of the input random access memories One end of each is coupled to a protocol processing engine The other end of the input random access memory is coupled to the patch processor. The other end of the patch processor is coupled to one end of all the output random access memories, and the other end of each output random access memory is coupled. Connect the other end of the protocol processing engine module.