An OpenFlow Large-Scale Flow Table Aggregation and Accelerated Lookup Method

Abstract

The present invention designs a flow table aggregation method based on an action set tree. According to masks, the original OpenFlow flow table is divided into several tuples, and then the flow table entries with possibly different action sets inside and outside the tuples are merged by constructing or synthesizing an action set tree. When a flow table is inserted or deleted, only the relevant table entries are aggregated or split to reduce the flow table update overhead. Further, the present invention provides a method for accelerating the lookup of large-scale OpenFlow flow tables. This method first separates the content fields of the flow table entries for storage using DRAM, and then compresses the matching fields of the flow table using the above-mentioned flow table aggregation method based on an action set tree, so that the TCAM can accommodate the vast majority or even all of the flow table entries. When the aggregated flow table still exceeds the capacity of the TCAM, the majority of the active flows are stored in the TCAM, and only a few idle flows are stored in the SRAM, so that most data packets can directly hit the TCAM to achieve fast forwarding.

Description

Technical Field

[0001] The present invention relates to a flow table aggregation method based on an action set tree, and an OpenFlow large-scale flow table aggregation and accelerated lookup method. Background Art

[0002] As an innovative network architecture, Software-Defined Networking (SDN) decouples the logical control function from data forwarding devices, constructs a logically centralized SDN control plane, and then provides a unified programming interface for upper-layer applications, thus greatly enhancing the openness, flexibility, and programmable ability of the network, and becoming one of the most promising development directions for the future of the Internet. The SDN control plane is responsible for constructing a global network view and formulating flow rules, and then sending them to switches in the data plane through a southbound interface protocol represented by OpenFlow to guide the forwarding behavior of network packets. OpenFlow uses the key fields in the protocol headers of each layer of the network as flow table matching fields, and introduces wildcards to achieve combinations of any fields, so as to flexibly define and manage network flows of different granularities. Since the TCAM memory supports tri-state data queries with wildcards and has the ability to search the entire data set in parallel, and can output the search result in one clock cycle, OpenFlow switches usually use TCAM to store flow tables to achieve fast wildcard search.

[0003] Figure 1 Shows the basic packet processing process of an OpenFlow switch, and its working principle is as follows:

[0004] (1) When an OpenFlow switch receives a packet p, it first parses and extracts the important fields in the protocol headers of each layer, and calculates its corresponding flow identifier fid; (2) uses the flow identifier fid to search the OpenFlow flow table, that is, parallelly matches all flow table entries in the TCAM memory; (3) if the flow table search is successful, it returns the matching table entry with the highest priority, and then executes the corresponding action set. (4) If the flow table search fails, the OpenFlow switch sends a flow installation request to the controller in the form of a Packet-in message. The controller then generates the corresponding flow rule according to the global network view, and then sends it to the switch and installs it in the OpenFlow flow table for forwarding and processing subsequent packets in the corresponding flow.

[0005] In an OpenFlow switch, the TCAM memory has high cost, low integration, and limited capacity. When SDN is deployed in a large-scale network with a large number of network concurrent flows, the number of OpenFlow flow entries increases significantly. At the same time, with the continuous evolution of the OpenFlow protocol version, the number of matching fields in the flow entries is increasing, resulting in an increasing width of a single flow entry. The multiplicative effect caused by these two aspects leads to a rapid increase in the flow table scale, making TCAM unable to meet the storage space requirements of the OpenFlow large-scale flow table. So far, the mainstream solution to alleviate the flow table storage problem is to use SRAM to cooperate with TCAM to store the flow table. However, SRAM uses address addressing mode and often implements wildcard lookup through the tuple space search method, with slow lookup speed. For the OpenFlow large-scale flow table, the number of flow entries stored in SRAM is large, the lookup overhead is high, and it is easy to generate a bottleneck in packet forwarding performance. In addition, the most promising method is to use flow table aggregation to merge multiple similar flow entries into one flow entry, enabling TCAM to accommodate the vast majority or even all OpenFlow flow entries, as follows:

[0006] As Figure 2 shown in [Solution 1] is a non-prefix flow table aggregation method BitWeaving. This method first divides orthogonal groups according to the bit information of the flow entry matching fields. Then, two techniques of bit swapping and bit merging are adopted to represent the flow entries within a single group in prefix form and merge the flow entries using the prefix aggregation algorithm. Finally, the matching fields of the flow entries are restored to the original bit sequence through bit reduction.

[0007] The aggregation process of Solution 1 is as follows: (1) First, arrange the flow entries in ascending order of the number of wildcard bits contained in the matching fields, and perform an AND operation on the masks of two adjacent flow entries in turn to determine whether cross-phenomena are introduced in the group, so as to divide orthogonal groups; (2) By swapping the bit order of the matching fields of the flow entries, convert the matching fields of the flow entries within each group into prefix form; (3) Through the weighted one-dimensional prefix aggregation algorithm, merge the flow entries with a Hamming distance of 1 and the same action set within the group; (4) Restore the flow entries according to the bit swapping order to obtain the original bit sequence of the matching fields of the flow entries, thus completing the OpenFlow flow table aggregation process.

[0008] As Figure 3 shown in [Solution 2] is a fast non-prefix flow table aggregation method FFTA. This method divides orthogonal groups according to the bit information of the flow entry matching fields, and then constructs a binary search tree within each group and iteratively aggregates each group to enable TCAM to store more flow entries. At the same time, this method uses an improved ORTC aggregation algorithm to cancel the bit swapping step of converting non-prefix to prefix in the traditional aggregation method, thereby improving the aggregation speed of the flow table.

[0009] The aggregation process of Solution 2 is as follows: (1) First, sort all flow table entries in ascending order according to the number of wildcards contained in the matching fields, and then perform orthogonal grouping based on the cross relationships between the flow table entries; (2) For each group, calculate the Least Common Ancestors (LCA) of all flow table entries in the group and set it as the root node of the binary search tree; (3) Decompose the non-leaf nodes from front to back according to the positions of the wildcards and continuously expand downwards, so that all flow table entries in the group are represented by leaf nodes to construct a binary search tree; (4) Use the improved ORTC aggregation algorithm to reduce the binary search tree; (5) Search layer by layer from bottom to top for two nodes with a Hamming distance of 1 and the same action set in the tree for merging, and finally obtain a flow table with a small scale and consistent forwarding semantics.

[0010] However, the existing flow table aggregation methods have the following disadvantages respectively:

[0011]

Solution 1

[0012]

Solution 2

[0013] Based on the above, the present invention provides a flow table aggregation method based on an action set tree and an OpenFlow large-scale flow table aggregation and accelerated lookup method. Summary of the Invention

[0014] The technical problem to be solved by the present invention is to design a flow table aggregation method, and then provide an OpenFlow large-scale flow table accelerated lookup method based on the flow table aggregation method proposed in this article to achieve fast flow table lookup of data packets.

[0015] To solve the above technical problems, the technical solution adopted by the present invention is as follows: An OpenFlow large-scale flow table aggregation and accelerated lookup method, mainly including a flow table aggregation method based on an action set tree and an OpenFlow large-scale flow table accelerated lookup architecture.

[0016] The idea of the flow table aggregation method based on the action set tree is as follows:

[0017] (1) First, all flow table entries in the original OpenFlow flow table are divided into different tuples in the aggregated flow table according to the mask;

[0018] (2) In each tuple, continuously select two flow table entries with a Hamming distance of 1 in the matching fields for merging, and place the merged new flow table entry into the corresponding tuple according to its mask for continued aggregation until no further aggregation is possible.

[0019] During the above merging process, an action set tree is generated for the action sets of all flow table entries to guide the forwarding processing operation of data packets.

[0020] When a new table entry is inserted into the flow table, first place it into the corresponding tuple, and then execute the above flow table entry aggregation process to complete the update of the flow table aggregation. If a flow table entry is deleted, first locate the corresponding aggregated table entry, and then perform necessary splitting on it, that is, reverse-decompose the aggregation process participated by the table entry to be deleted, and finally delete the table entry. In short, each time the flow table is updated, only the relevant table entries need to be updated, rather than re-aggregating the entire flow table. Therefore, the flow table aggregation method proposed in this patent not only has a high degree of aggregation but also has the advantage of fast update speed.

[0021] The above flow table entry aggregation process allows the flow table entries to be merged to have different action sets to relax the aggregation conditions and increase the merging opportunities. To ensure the correctness of the data packet processing semantics, this patent uses a Trie tree structure to construct an action set tree for each aggregated table entry. In this action set tree, non-leaf nodes record the bit position information when the flow table entries are merged, and leaf nodes save the action sets and priorities of the original flow table entries to determine the corresponding action set after the data packet successfully matches the aggregated table entry.

[0022] When the flow table is updated, the corresponding action set tree needs to be updated. If a flow table entry is inserted, execute the flow table entry aggregation process, and when merging the flow table entries each time, combine the original two action sets (trees) into a new action set tree. If a flow table entry is deleted, first find the corresponding aggregated table entry, locate the corresponding action set tree, and then start splitting from the root node along the direction of the action set leaf node of the flow table entry to be deleted. At the same time, use the bit position information saved by the non-leaf nodes to restore the flow table entry and its action set (tree), store them in the flow table, and finally execute the flow table entry deletion operation.

[0023] The design idea of the OpenFlow large-scale flow table acceleration lookup architecture is as follows:

[0024] First, the content fields in the flow table entries are separated and stored in DRAM, effectively alleviating the problem of tight TCAM storage resources. For the matching fields of the flow table entries, the above-mentioned flow table aggregation method based on the action set tree is used for compression, so that TCAM can accommodate most or even the entire OpenFlow flow table. If TCAM still cannot fully accommodate the aggregated flow table, the flow table entries are divided into two parts according to activity, forming a TCAM sub-flow table and an SRAM sub-flow table, which store active flows and idle flows respectively, so that most data packets can directly hit TCAM.

[0025] An OpenFlow large-scale flow table aggregation and acceleration lookup method provided by the present invention has at least the following beneficial effects:

[0026] 1. A flow table aggregation method based on the action set tree provided by the present invention divides all flow table entries in the original flow table into several tuples according to the mask, then merges the flow table entries with a Hamming distance of 1 in the matching fields of each tuple, and constructs an action set tree to save the action sets of the merged flow table entries. The aggregation condition is loose. Further, the merged flow table entries are redirected to the corresponding tuples through the mask and continue to be aggregated with the flow table entries in the tuple. Aggregation is performed in this way until there are no flow table entries in the tuple where the newly aggregated table entries are located that can be aggregated with them. The aggregation effect is good. When a flow table is inserted or deleted, only the relevant flow table entries are aggregated or split, and the flow table update speed is fast.

[0027] 2. The OpenFlow large-scale flow table acceleration lookup method provided by the present invention first separates the content fields of the flow table entries and stores them in DRAM, and then uses the above-mentioned flow table aggregation method based on the action set tree to compress the matching fields of the flow table, so that TCAM can accommodate most or even all flow table entries. Further, when the aggregated flow table still exceeds the TCAM capacity, most active flows are stored in TCAM, and only a few idle flows are stored in SRAM, so that most data packets can directly hit TCAM to achieve fast forwarding.

[0028] 3. Compared with the first solution of the prior art, for the defects existing in the first solution, the present invention first divides the original OpenFlow flow table into several tuples according to the mask, and then directly merges the flow table entries with a Hamming distance of 1 in each tuple, without exchanging bit sequences for prefix aggregation, so as to reduce the flow table aggregation overhead. At the same time, when a flow table is inserted or deleted, only the relevant flow table entries are aggregated or split to achieve fast update of the flow table.

[0029] 4. Compared with the second solution of the prior art, in view of the defects existing in the second solution, by constructing an action set tree, flow table entries with possibly different action sets can be merged, and the merged flow table entries can be relocated to other tuples according to their masks for further aggregation, so as to significantly increase the aggregation opportunities. For inserting or deleting a table entry in the flow table, only the relevant table entries need to be aggregated or split, without reconstructing the action set tree, so as to significantly reduce the flow table update overhead. BRIEF DESCRIPTION OF THE DRAWINGS

[0030] In order to more clearly illustrate the technical solutions in the embodiments of the present invention or the prior art, the following will briefly introduce the drawings required for use in the description of the embodiments or the prior art. Obviously, the following drawings are only some embodiments of the present invention. For those of ordinary skill in the art, other drawings can be obtained based on these drawings without creative efforts.

[0031] Figure 1 Schematic diagram of the basic packet processing process for an OpenFlow switch;

[0032] Figure 2 Schematic diagram of the prior art BitWeaving flow table aggregation method;

[0033] Figure 3 Example diagram of the prior art FFTA flow table aggregation method;

[0034] Figure 4 Flow table entry aggregation process diagram in the flow table aggregation method provided by the embodiment of the present invention;

[0035] Figure 5 Design diagram of the action set tree based on the Trie tree structure provided by the embodiment of the present invention;

[0036] Figure 6 Schematic diagram of an OpenFlow large-scale flow table accelerated lookup architecture provided by the embodiment of the present invention;

[0037] Figure 7 Schematic diagram of an OpenFlow packet forwarding process provided by the embodiment of the present invention;

[0038] Figure 8 Schematic diagram of an OpenFlow flow table dump process provided by the embodiment of the present invention;

[0039] Figure 9 Schematic diagram of an OpenFlow flow table insertion process provided by the embodiment of the present invention;

[0040] Figure 10 Schematic diagram of an OpenFlow flow table aggregation process provided by the embodiment of the present invention;

[0041] Figure 11 Schematic diagram of an OpenFlow flow table deletion process provided for the implementation of the present invention;

[0042] Figure 12 Schematic diagram of an OpenFlow flow table entry splitting process provided for the implementation of the present invention;

[0043] Figure 13 Example diagram of a flow table aggregation method based on an action set tree provided for the implementation of the present invention. Detailed implementation manners

[0044] The present invention will be further described below in conjunction with embodiments and the accompanying drawings, but it is not used to limit the scope of the present invention.

[0045] As Figure 4 shown, an embodiment of the present invention provides a flow table aggregation method based on an action set tree. The specific aggregation process is as follows:

[0046] For a newly added flow table entry, first locate the corresponding tuple according to its mask, and then search for a flow table entry with a Hamming distance of 1 from its matching field in it. If the search is successful, use the wildcard "*" to replace the bits where the matching fields of the two are different, so as to merge the two flow table entries, and generate a new action set tree according to their priorities and action sets (trees). For the merged flow table entry, it needs to be placed in other tuples according to its mask, and the flow table entry merging and action set tree update continue until the newly generated flow table entry can no longer be merged.

[0047] As Figure 5 shown, an embodiment of the present invention provides an action set tree based on a Trie tree structure. The specific construction and use are as follows:

[0048] For two flow table entries to be merged, first create a root node, record the positions where the bits in the matching fields of the two flow table entries are different, and then use the action sets (trees) of the two flow table entries as its left and right child nodes, thus forming a new action set tree. Repeat the above operations to finally complete the construction of the action set tree of the aggregated table entries. For the arriving data packet, if it successfully matches an aggregated table entry, first obtain the action set tree in it, then search the action set tree according to the matching field of the data packet to locate a leaf node, and finally forward and process the data packet according to the action set in it. If the data packet successfully matches multiple flow table entries to obtain multiple action sets, the action set with the highest priority is used for processing.

[0049] As Figure 6 shown, an embodiment of the present invention provides an OpenFlow large-scale flow table aggregation and accelerated lookup method. The specific data packet flow table lookup process is as follows:

[0050] When an OpenFlow switch receives a data packet, it first extracts its matching fields and then looks up the TCAM sub-flow table. If a flow table entry is successfully found, it locates the corresponding DRAM sub-entry according to the index therein, and then performs the corresponding forwarding processing operation according to its action set (tree). Otherwise, it further looks up the SRAM sub-flow table. If the lookup is successful, the data packet is forwarded according to the corresponding DRAM sub-entry. If the entire OpenFlow flow table lookup fails, the data packet information is encapsulated into a flow installation request and sent to the controller to request the corresponding flow rule to be issued. Since TCAM stores the vast majority of active flows, the vast majority of data packets can be directly forwarded through TCAM, thus ensuring the flow table lookup performance of the data packets.

[0051] Refer to Figures 7 - 13 , the above embodiments specifically include the following operations:

[0052] a. OpenFlow packet forwarding operation

[0053] As Figure 7 shown is the OpenFlow packet forwarding process. When an OpenFlow switch receives a certain data packet in the network, it first parses its header fields and extracts its matching fields, and then looks up the TCAM sub-flow table. If the lookup is successful, it reads the corresponding DRAM sub-entry according to the index value in the matching TCAM sub-entry, and then looks up the action set (tree) therein. Finally, it forwards and processes the data packet according to the found action set, and updates the content fields such as the counter and timestamp in the DRAM sub-entry. If the TCAM lookup fails, it further looks up the SRAM sub-flow table. If the lookup is successful, the data packet is also forwarded and the content fields are updated according to the corresponding DRAM sub-entry. At this time, if the flow to which the data packet belongs enters the active state, the flow is transferred from the SRAM sub-flow table to the TCAM sub-flow table. If both the TCAM and SRAM sub-flow table lookups fail, it means that the data packet belongs to a new flow, so the data packet information is encapsulated into a packet-in message and sent to the controller to request the controller to issue the corresponding flow rule.

[0054] b. OpenFlow flow table entry transfer operation

[0055] As Figure 8 shown is the OpenFlow flow table entry transfer process. When a data packet successfully matches an SRAM sub-flow table entry, if the flow to which it belongs enters the active state, the flow needs to be transferred from the SRAM sub-flow table to the TCAM sub-flow table. First, obtain the number of flow table entries in the TCAM, and then compare the activity of each flow table entry one by one to find the flow table entry with the lowest activity as the flow table entry to be exchanged. Then, transfer the flow table entry to be exchanged to the SRAM sub-flow table, and transfer the currently active flow table entry to the TCAM sub-flow table.

[0056] c. OpenFlow flow table insertion operation

[0057] As Figure 9 shown is the OpenFlow flow table insertion process. When the OpenFlow switch receives a Flow-Mod message with an ADD command sent by the SDN controller, it first creates a new flow table entry according to the message content, and then aggregates it in the TCAM sub-flow table. If the aggregation is successful, the matching field and content field of the generated aggregated table entry are stored in the TCAM and DRAM sub-flow tables respectively. If the aggregation fails, it is further aggregated in the SRAM sub-flow table, otherwise the matching field and content field corresponding to the generated table entry are also stored in the SRAM and DRAM sub-flow tables respectively. If both the TCAM and SRAM sub-flow table aggregations fail, the matching field and content field are stored in the SRAM and DRAM sub-flow tables respectively.

[0058] d. OpenFlow flow table aggregation operation

[0059] As Figure 10 shown is the OpenFlow flow table aggregation process. When the OpenFlow switch receives a flow table entry to be aggregated, it first searches for flow table entries with a Hamming distance of 1 from it in the TCAM and SRAM sub-flow tables according to its mask. If the search is successful, a new action set tree is constructed, that is, a new root node is created, and the bit position bp where the matching fields of the two flow table entries are different is stored in it, and then the action sets (trees) corresponding to the two flow table entries are used as the left and right children of the root node. Further, a new merged table entry is generated, and the merged flow table entries are deleted at the same time. Then continue to search for flow table entries that meet the aggregation conditions in the flow table until the newly generated flow table entry can no longer be merged. Finally, the aggregation result is output, that is, whether aggregation is performed and the aggregated flow table entry.

[0060] e. OpenFlow flow table deletion operation

[0061] As Figure 11The following is the OpenFlow flow table deletion process. When an OpenFlow switch receives a Flow-Mod message with a DELETE command sent by the SDN controller, it first extracts the matching fields of the flow in the flow rule, and then searches for the entry to be deleted in the TCAM sub-flow table. If the search is successful, if the matching TCAM sub-entry is a non-aggregated entry, then first read the corresponding DRAM sub-entry according to the index value therein and delete it, and then delete the TCAM sub-entry. Otherwise, enter the OpenFlow flow table entry splitting process. After the flow table entry splitting is completed, use the index value in the entry to be deleted to read the corresponding DRAM sub-entry and delete it. If the TCAM search fails, further search the SRAM sub-flow table. If the search is successful, perform the flow table entry deletion and flow table entry splitting operations in the same way as above. If both the TCAM and SRAM sub-flow table searches fail, send an error message to the controller to report the failure result of the flow table entry deletion.

[0062] f. OpenFlow flow table entry splitting operation

[0063] As Figure 12 The following is the OpenFlow flow table entry splitting process. When an OpenFlow switch needs to delete a flow table entry from an aggregated flow table entry, first locate the action set tree in the corresponding DRAM sub-entry according to the index value in the aggregated flow table entry. Then, start splitting the action set tree from the root node downwards until the leaf node corresponding to the flow table entry to be deleted is obtained. Next, except for the flow table entry to be deleted, re-insert all the split flow table entries into the flow table. Finally, remove the aggregated flow table entry.

[0064] As Figure 13 The following shows the aggregation example of the flow table aggregation method proposed by the present invention, and the specific content is as follows:

[0065] The left dotted green box in the figure represents a tuple, and the flow table entries therein are simplified and represented in the form of a binary tuple <matching field, action set>. Process ① represents the merging process of two flow table entries with a Hamming distance of 1 within the same tuple, process ② represents the construction process of the action set tree according to the bit position during the merging, and process ③ represents re-placing the aggregated new entry into the corresponding tuple to continue the aggregation.

[0066] Compared with the prior art, the present invention designs a flow table aggregation method based on an action set tree. The method divides the original OpenFlow flow table into several tuples according to a mask, and then merges the flow table entries with possibly different action sets inside and outside the tuples by constructing or synthesizing an action set tree. When a flow table is inserted or deleted, only the relevant entries are aggregated or split to reduce the flow table update overhead. Further, the present invention provides an accelerated lookup method for large-scale OpenFlow flow tables. The method first separates the content fields of the flow table entries and stores them in DRAM, and then compresses the matching fields of the flow table using the above-mentioned flow table aggregation method based on an action set tree, so that the TCAM can accommodate the vast majority or even all of the flow table entries. When the aggregated flow table still exceeds the capacity of the TCAM, the majority of the active flows are stored in the TCAM, and only a small number of idle flows are stored in the SRAM, so that most data packets can directly hit the TCAM for fast forwarding.

[0067] The foregoing has shown and described the basic principles, main features and advantages of the present invention. Those skilled in the art should understand that the present invention is not limited by the above embodiments. The above embodiments and the description in the specification are only used to illustrate the principle of the present invention. Without departing from the spirit and scope of the present invention, the present invention will have various changes and improvements, and all these changes and improvements fall within the scope of the present invention claimed. The scope of the present invention claimed is defined by the appended claims and their equivalents.

Claims

1. An OpenFlow flow table aggregation method based on an action set tree. This method first divides all flow table entries in the original OpenFlow flow table into different tuples in the aggregated flow table according to the mask. Then, in each tuple, two flow table entries with a Hamming distance of 1 for the matching fields are continuously selected for merging, and the merged new flow table entry is placed in the corresponding tuple according to its mask for continued aggregation until no further aggregation is possible. During the above merging process, an action set tree is generated for all flow table entries to guide the forwarding processing operation of data packets. It is characterized in that, The action set tree based on the Trie tree structure, where non-leaf nodes record the bit position information during the aggregation of flow table entries, and leaf nodes store the action set and priority of the original flow table entry, which are used to determine the corresponding action set after a data packet successfully matches the aggregated table entry. The specific operations include the following: (1) OpenFlow packet forwarding operation, that is, for each data packet arriving at the OpenFlow switch, the corresponding flow table entry is found by looking up the flow table, and then the packet is forwarded according to the action set therein; when a data packet successfully matches the SRAM sub-flow table, if the flow to which it belongs enters the active state, a dump operation needs to be performed on the table entry matched by the data packet; (2) OpenFlow flow table insertion operation, that is, when the OpenFlow switch receives a Flow_Mod message with an ADD command sent by the SDN controller, a new flow table entry needs to be created according to the message content, then it is aggregated in the OpenFlow sub-flow table, and the corresponding action set tree is constructed; (3) OpenFlow flow table deletion operation, when the OpenFlow switch receives a Flow_Mod message with a DELETE command sent by the SDN controller, the corresponding flow table entry needs to be deleted; if the table entry to be deleted is an aggregated table entry, it needs to be disassembled and restored, and then the corresponding flow table entry is deleted.

2. The OpenFlow flow table aggregation method based on an action set tree according to claim 1, wherein The specific steps of the above-mentioned OpenFlow packet forwarding operation are as follows: First, parse its header fields and extract its matching fields, and then look up the TCAM sub-flow table; if the lookup is successful, read the corresponding DRAM sub-table entry according to the index value in the matching TCAM sub-table entry, and then look up the action set tree therein. Finally, forward and process the data packet according to the found action set, and update the counter and timestamp content fields in the DRAM sub-table entry; if the TCAM lookup fails, further look up the SRAM sub-flow table; if the lookup is successful, also perform data packet forwarding processing and content field update according to the corresponding DRAM sub-table entry. If the flow to which the data packet belongs enters the active state, transfer the flow from the SRAM sub-flow table to the TCAM sub-flow table; if both the TCAM and SRAM sub-flow table lookups fail, it means that the data packet belongs to a new flow. Therefore, encapsulate the data packet information into a packet-in message and send it to the controller to request the controller to issue the corresponding flow rule.

3. The OpenFlow flow table aggregation method based on an action set tree according to claim 1, characterized in that The idea of the above-mentioned OpenFlow flow table entry dump operation is as follows: First, obtain the number of flow table entries in the TCAM, and then compare the activity of each flow table entry one by one. Find the flow table entry with the lowest activity as the flow table entry to be exchanged, and transfer the flow table entry to be exchanged to the SRAM sub-flow table. Then transfer the currently active flow table entry to the TCAM sub-flow table.

4. A method for aggregating OpenFlow flow tables based on an action set tree according to claim 1, characterized in that, The OpenFlow flow table insertion operation specifically includes the following steps: First, a new flow table entry is created according to the message content, and then it is aggregated in the TCAM sub-flow table; if the aggregation is successful, the matching field and the content field of the generated aggregated table entry are respectively stored in the TCAM and DRAM sub-flow tables; if the aggregation fails, it is further aggregated in the SRAM sub-flow table, otherwise the matching field and the content field corresponding to the generated table entry are also respectively stored in the SRAM and DRAM sub-flow tables; if both the TCAM and SRAM sub-flow table aggregations fail, the matching field and the content field are respectively stored in the SRAM and DRAM sub-flow tables.

5. A method for aggregating OpenFlow flow tables based on an action set tree according to claim 1, wherein The OpenFlow flow table aggregation operation specifically includes the following steps: First, flow table entries with a Hamming distance of 1 from it are searched in the TCAM and SRAM sub-flow tables according to its mask; if the search is successful, a new action set tree is constructed, that is, a root node is created, and the bit position bp where the matching fields of the two flow table entries are different is stored in it, and then the action set trees corresponding to the two flow table entries are used as the left and right children of the root node to further generate a new merged table entry, and at the same time the merged flow table entries are deleted; then continue to search for flow table entries that meet the aggregation conditions in the flow table until the newly generated flow table entry can no longer be merged; finally, the aggregation result is output, that is, whether aggregation is performed and the aggregated flow table entry.

6. The OpenFlow flow table aggregation method based on an action set tree according to claim 1, wherein The OpenFlow flow table deletion operation specifically includes the following steps: First, the matching field of the flow in the flow rule is extracted, and then the table entry to be deleted is searched in the TCAM sub-flow table; if the search is successful, if the matching TCAM sub-table entry is a non-aggregated table entry, then first read the corresponding DRAM sub-table entry according to the index value in it and delete it, and then delete the TCAM sub-table entry, otherwise enter the OpenFlow flow table entry splitting process. After the flow table entry splitting is completed, the corresponding DRAM sub-table entry is read using the index value in the table entry to be deleted and deleted; if the TCAM search fails, then further search the SRAM sub-flow table. If the search is successful, the flow table entry deletion and flow table entry splitting operations are also performed by the above method; if both the TCAM and SRAM sub-flow table searches fail, an error message is sent to the controller to report the failure result of the flow table entry deletion.

7. A method for aggregating OpenFlow flow tables based on an action set tree according to claim 1, characterized in that The OpenFlow flow table entry splitting operation specifically includes the following steps: First, according to the index value in the aggregated flow table entry, locate the action set tree in its corresponding DRAM sub-table entry, and then split the action set tree from the root node downwards until the leaf node corresponding to the flow table entry to be deleted is obtained. Further, except for the flow table entry to be deleted, all the flow table entries obtained by splitting are re-inserted into the flow table, and the aggregated flow table entry is removed.

Images