A deep aggregation method and fast search system for OpenFlow flow tables

Abstract

The present invention designs an OpenFlow flow table deep aggregation method, which divides the original flow table in OpenFlow into several tuples according to the mask, then performs double bit merging on the flow table items in each tuple, and constructs the content field (including action set) of the aggregated table item into a content table item tree according to the merged bit position, and then puts the aggregated table item into the corresponding tuple according to its mask for further aggregation, until it cannot be aggregated or the content table item tree reaches the upper limit. Further, the present invention provides an OpenFlow flow table deep aggregation storage system. The system uses the above-mentioned flow table deep aggregation method to compress the OpenFlow flow table, and strips out the content fields of all flow table items to construct a content table item tree and uses SRAM to store it separately, so that TCAM can accommodate the entire flow table. At the same time, the system limits the height of the content table item tree to ensure access and search speed. In addition, an aggregation acceleration sub-flow table is designed to specifically perform table item aggregation operations, thereby speeding up the flow table aggregation speed.

Description

Technical Field

[0001] The present invention relates to the field of flow table aggregation in software defined networks, and more specifically, to an OpenFlow flow table deep aggregation method and a fast search system. Background Art

[0002] Software Defined Networking (SDN) is a new network architecture with data control separation and software programmability. It uses OpenFlow technology to separate the control plane and the data plane. The control plane is responsible for central management and forwarding policy allocation, and the network devices in the data plane can only forward data packets. SDN uses the southbound interface for communication between its data planes to improve the flexibility, development and scalability of network management. It can simply and efficiently implement the installation of new network control policies and is extremely easy to deploy. In the SDN data plane, the OpenFlow protocol is mainly used as its southbound interface protocol. OpenFlow matches forwarding rules based on the concept of flow, uses the important fields of the headers of each layer of network protocols as the matching domain of the flow table items, and supports the combination of any fields through wildcards, thereby realizing fine-grained and flexible management of network flows. Since the TCAM memory supports three types of data lookups: "0, 1, and intermediate state", and all entries in the TCAM table can be accessed in parallel, all results can be output in a single cycle, so OpenFlow switches usually use TCAM to store flow tables to achieve fast forwarding of data packets in the network.

[0003] Figure 1 The OpenFlow flow table search process is shown. Its working principle is as follows:

[0004] (1) When the OpenFlow switch receives a data packet p i When a packet is received, the packet header is first parsed to extract important fields in the header (such as source / destination IP address, source / destination port, protocol type, etc.), and the corresponding flow identifier fid is calculated; (2) the flow identifier fid is used to search the OpenFlow flow table, that is, all flow table entries in the TCAM memory are matched in parallel; (3) if the flow table search is successful, the matching table entry with the highest priority is returned, and then the corresponding action set is executed. (4) if the flow table search fails, the packet header information will be encapsulated into a packet-in message and sent to the SDN controller. The controller generates a new flow rule based on the global network view and sends it to the OpenFlow switch, which is added to the corresponding flow table for forwarding and processing packets with the same flow identifier.

[0005] Packet classification is the core mechanism for implementing many network services on the Internet. Ternary Content Addressable Memory (TCAM) has become the de facto standard for fast packet classification in the industry. In order to achieve fast lookup in the flow table, OpenFlow switches use TCAM to design flow tables. However, TCAM memory is costly, has limited capacity, low integration, and high energy consumption. When SDN is deployed in large-scale networks such as data centers and integrated space-ground information networks, the number of flow table entries increases dramatically due to the large number of concurrent flows in the network. At the same time, as the number of services deployed on the Internet continues to increase, the number of rules is also increasing rapidly. Therefore, it is difficult for TCAM to meet the storage requirements of OpenFlow large-scale flow tables. In response to the problem of tight flow table storage resources, the current mainstream solution is to put TCAM and SRAM together to store flow table entries. However, SRAM uses address addressing and can only achieve wildcard lookup through tuple space search method, which is significantly slower than TCAM. In addition, the most promising method is to use flow table aggregation to merge multiple similar flow table entries into one flow table entry, so that TCAM can store the entire flow table, as follows:

[0006] like Figure 2 The [Scheme 1] shown is a Bit Weaving method for aggregating non-prefix multi-field entries. This method first groups all non-prefix entries into orthogonal groups (dividing them into the smallest non-crossing partitions), and then uses bit exchange and bit merging techniques within a single group to arrange non-prefix entries into prefix rules by adjusting the bit sequence, and then aggregates them using the prefix entry aggregation algorithm. Finally, all flow entries are restored to their original sequence through bit restoration.

[0007] The aggregation process of scheme 1 is as follows: (1) First, the flow table items are sorted in ascending order according to the number of "*" in their matching fields, and the masks of two adjacent flow table items are ANDed in turn to perform minimum non-crossing partitioning, thereby realizing orthogonal grouping; (2) In each group, the non-prefix form flow table items are converted into prefix form by exchanging columns, and then the weighted one-dimensional prefix list minimization algorithm is used to aggregate the flow table items with a matching field Hamming distance of 1 and the same action set into an aggregated table item; (3) The prefix form flow table items are restored to the original bit sequence through bit restoration to complete the aggregation process.

[0008] like Figure 3The [Scheme 2] shown is an efficient flow rule reduction algorithm EFRR. This method first represents the matching fields of all flow table items in the form of a binary tree. Then, the ORTC algorithm is used to compress the flow table items in prefix form, and the modified QM (Modified Quine-McCluskey, MQM) algorithm is used to compress the rules again, thereby reducing the number of flow rules in the OpenFlow switch and improving the performance of SDN.

[0009] The aggregation process of scheme 2 is as follows: (1) First, a binary tree is constructed based on the matching field of the flow table item (with the destination IP address as the matching field). Each consecutive bit in the matching field corresponds to a link of a child node in the tree, 0 corresponds to the left child node, and 1 corresponds to the right child node; (2) The ORTC algorithm is used to reduce the binary tree; (3) The MQM algorithm is used to compress the flow rules, which is essentially the same as the bit merging principle in bit weaving, that is, two flow rules with a matching field Hamming distance of 1 are merged to finally obtain a smaller flow table.

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

[0011] [Solution 1] uses two new technologies, bit exchange and bit merging, and uses a weighted one-dimensional prefix list minimization algorithm for aggregation. However, this method is relatively complex to operate when aggregating table items, has high aggregation overhead, and the aggregation speed slows down as the number of flow table items increases. In large-scale OpenFlow flow tables, the flow table aggregation time is relatively long. In addition, when the flow table is updated, it is difficult to update the table items, and it may even be necessary to re-execute the BitWeaving algorithm in the group, which has a huge update overhead.

[0012] [Solution 2] Based on the binary tree constructed from all flow items, the ORTC algorithm is used to compress the flow items, and then the improved QM algorithm is used to compress the rules again. However, although this method takes priority into consideration, that is, the aggregated items are forwarded according to the action with the highest priority of the original flow items before aggregation, it is easy to cause forwarding semantic errors. At the same time, the aggregation of this method requires the flow item action set to be consistent, and the aggregation is limited to the flow items with a Hamming distance of 1 in the aggregation match field, so there are fewer aggregation opportunities.

[0013] Based on the above, the present invention provides an OpenFlow flow table deep aggregation method and an OpenFlow flow table deep aggregation storage system. Summary of the invention

[0014] The technical problem to be solved by the present invention is to design an OpenFlow flow table aggregation method, and then provide an OpenFlow flow table deep aggregation storage system based on the flow table aggregation method proposed in this article to achieve fast lookup of the flow table.

[0015] In order to solve the above technical problems, the technical solution adopted by the present invention is: an OpenFlow flow table deep aggregation method and a fast search system, which mainly include an OpenFlow flow table deep aggregation method and an OpenFlow flow table deep aggregation storage system.

[0016] The design ideas of the OpenFlow flow table deep aggregation storage system are as follows:

[0017] The system consists of a matching subflow table, an aggregation acceleration backup table, and a content subflow table. The matching subflow table uses TCAM to store the matching fields of all items after the OpenFlow flow table is aggregated to achieve fast search of data packets. Among them, the matching field of each flow table item is used to identify the flow, the mask field is used to mark the position of the wildcard in the matching field, and the index field indicates the corresponding flow table item in the aggregation acceleration backup table. The aggregation acceleration backup table divides all flow table items in the matching subflow table into several tuples according to the mask for storage, so as to quickly aggregate the items. The content subflow table stores the content table item tree of all items after the OpenFlow flow table is aggregated, which corresponds one-to-one to all items in the matching subflow table. SRAM storage is usually used to achieve fast access and search. Each content table item tree stores the content field (including action set) of the aggregated table item to ensure the correctness of the packet forwarding semantics.

[0018] The idea of ​​the OpenFlow flow table deep aggregation method is as follows:

[0019] (1) First, the original OpenFlow flow table is divided into several tuples according to the mask, and then the aggregation order of the table items with a larger aggregation degree is selected for each tuple;

[0020] (2) If the aggregation degrees of the two aggregation orders are the same, the flow table entries whose matching field Hamming distance is 1 are prioritized to reduce the height of the content table entry tree, thereby reducing the search overhead of the content table entry tree;

[0021] (3) Aggregate the items in the tuple according to the selected order, and place the aggregated items into the corresponding tuple according to their masks for further aggregation until the number of levels of the content item tree reaches a preset threshold.

[0022] In the above merging process, the content fields (including action sets) of all flow table entries are used to generate a corresponding content table entry tree for guiding the forwarding processing operation of the data packet.

[0023] For the flow table items to be inserted, first add them to the corresponding tuple according to their masks, and then search for flow table items that can be aggregated with them in the tuple. If only flow table items with Hamming distances of 1 or 2 are found, and the content table item tree height does not exceed the preset threshold, they are directly merged; if flow table items with Hamming distances of both 1 and 2 are found, and the content table item tree height does not exceed the preset threshold, a method with a higher degree of aggregation is selected for aggregation according to the predicted results, and the aggregated items are placed in the corresponding tuple according to their masks for further aggregation. Repeat the above operations until the content table item tree height reaches the threshold. For the flow table items to be deleted, first search for the aggregated flow table. If the matching table item is a non-aggregate table item, that is, its content table item tree has only one node, it can be deleted directly. Otherwise, find the corresponding content table item tree according to its matching field, and delete the leaf node corresponding to the table item to be deleted.

[0024] The above-mentioned flow table aggregation process supports table items with different aggregation action sets to improve the degree of aggregation. In order to ensure the correctness of the packet forwarding semantics, this patent uses a binary tree structure to construct a corresponding content table item tree for each aggregation table item. In the content table item tree, non-leaf nodes record the merged bit positions when the table items are aggregated, and leaf nodes store the content fields (including action sets) of the original table items. For the arriving packets, if an aggregation table item is successfully matched, the corresponding content table item tree is first located, and then the corresponding leaf node is found in the content table item tree according to the matching field of the packet, and the corresponding action set is obtained to achieve correct packet forwarding. If multiple flow table items are successfully matched, the packet is forwarded according to the action set with a higher priority.

[0025] When the flow table is updated, the corresponding content table item tree needs to be updated. For the flow table item to be inserted, if it is included in the existing flow table item, the flow table item is directly merged, and its action set is set as the leaf node of the corresponding content table item tree, otherwise try to aggregate the table items. If it can be aggregated, then each time the table items are aggregated, the content table item tree of the aggregated table items will be merged into a new content table item tree according to the above process. For the flow table item to be deleted, if it is an aggregated table item, first locate the corresponding content table item tree, and then search for the corresponding leaf node in the content table item tree according to the matching field of the table item to be deleted. If the search is successful, delete the leaf node, and reversely delete all nodes without child nodes.

[0026] The present invention provides an OpenFlow flow table deep aggregation method and a fast search system, which have at least the following gain effects:

[0027] 1. The present invention provides a method for deep aggregation of flow tables based on a content table item tree. The original OpenFlow flow table is divided into several tuples according to a mask, and then the requirement for item aggregation is relaxed from a Hamming distance of only 1 to 2. Then, in each tuple, the table items are merged according to an optimized aggregation order, and a content table item tree is constructed to aggregate flow table items with different content fields (including action sets), while ensuring the correctness of packet forwarding semantics. After each table item aggregation, the aggregated table item is further aggregated by placing it into the corresponding tuple according to its mask, and the corresponding content table item tree is updated until the number of layers of the content table item tree reaches the upper limit. When the flow table is inserted or deleted, only the relevant flow table items are updated, and the flow table is updated quickly.

[0028] 2. The present invention provides an item aggregation optimization strategy for double bit merging, which first aggregates items according to different item aggregation orders, that is, prioritizes the aggregation of flow items with a Hamming distance of 1 or 2, and then selects an order with a higher degree of aggregation, that is, aggregates more items. If the aggregation degrees of the two orders are the same, the flow items with a matching field Hamming distance of 1 are prioritized for aggregation to reduce the height of the content item tree, thereby reducing the search overhead of the content item tree.

[0029] 3. The present invention provides an OpenFlow flow table deep aggregation storage system, which uses the above-mentioned flow table deep aggregation method to compress the OpenFlow flow table, and strips out the content fields (including action sets) of all flow table items to construct a content table item tree and uses SRAM to store it separately, so that TCAM can accommodate the entire flow table. At the same time, the system limits the height of the content table item tree, thereby ensuring the access and search speed of the OpenFlow flow table. In addition, the aggregation acceleration sub-flow table is designed specifically for performing table item aggregation operations, thereby speeding up the flow table aggregation speed.

[0030] 4. Compared with the scheme 1 of the prior art, the present invention addresses the defects of the scheme 1. Based on the flow table entries with a Hamming distance of 1 in the aggregation matching field, the present invention extends the case of a Hamming distance of 2, and does not need to exchange the bit sequence in the flow table entry matching field, thereby increasing the aggregation opportunities, reducing the number of aggregations, and reducing the flow table aggregation overhead. At the same time, when the flow table is updated, only the relevant flow table entries need to be aggregated or deleted to achieve a rapid update of the flow table.

[0031] 5. Compared with the second solution of the prior art, the present invention addresses the defects of the second solution by constructing a content table item tree to aggregate flow table items with different action sets, and the aggregated table items can be relocated to another tuple according to the mask for further aggregation, thereby increasing the aggregation opportunities and ensuring correct forwarding. At the same time, when the flow table is updated, that is, when the flow table is inserted or deleted, only the relevant content table item tree is aggregated or deleted, without the need to rebuild the content table item tree, thereby reducing the flow table update overhead and realizing rapid flow table update. BRIEF DESCRIPTION OF THE DRAWINGS

[0032] In order to more clearly illustrate the embodiments of the present invention or the technical solutions in the prior art, the drawings required for use in the embodiments or the description of the prior art will be briefly introduced below. Obviously, the drawings described below are only some embodiments of the present invention. For ordinary technicians in this field, other drawings can be obtained based on these drawings without paying creative work.

[0033] Figure 1 This is a schematic diagram of the mainstream search process of the OpenFlow flow table;

[0034] Figure 2 It is a schematic diagram of the BitWeaving flow table aggregation method in the prior art;

[0035] Figure 3 It is an example diagram of the EFRR flow table compression method in the prior art;

[0036] Figure 4 An OpenFlow flow table deep aggregation storage architecture diagram provided for the implementation of the present invention;

[0037] Figure 5 A flow table item aggregation process diagram in a flow table aggregation method provided for implementation of the present invention;

[0038] Figure 6 A content table item tree design diagram based on a binary tree structure provided for the implementation of the present invention;

[0039] Figure 7 A schematic diagram of an OpenFlow packet forwarding process provided for the implementation of the present invention;

[0040] Figure 8 A schematic diagram of an OpenFlow flow table insertion process provided for the implementation of the present invention;

[0041] Fig. 9 A schematic diagram of a content table item tree construction process provided for the implementation of the present invention;

[0042] Fig.10 A schematic diagram of an OpenFlow flow table deletion process provided for the implementation of the present invention;

[0043] Fig.11 An example diagram of a flow table deep aggregation method based on a content table item tree provided for the implementation of the present invention. DETAILED DESCRIPTION

[0044] The invention is further described below in conjunction with the embodiments and drawings, but they are not intended to limit the scope of the invention.

[0045] like Figure 4 As shown, an embodiment of the present invention provides an OpenFlow flow table deep aggregation storage system, and the specific data packet flow table search process is as follows:

[0046] When an OpenFlow switch receives a data packet, it first extracts its matching fields and then searches for matching sub-flow tables. If a flow table entry is successfully found, the corresponding content table entry tree in the content sub-flow table is located according to the index therein, and then the corresponding forwarding processing operation is performed according to its action set (tree). Otherwise, the data packet information is encapsulated into a flow installation request and sent to the controller to request the corresponding flow rules to be issued.

[0047] like Figure 5 As shown, an embodiment of the present invention provides an OpenFlow flow table deep aggregation method, and the specific aggregation process is as follows:

[0048] For a newly added flow table entry, first locate the corresponding tuple according to its mask, and then search for flow table entries that can be aggregated with it in the tuple. If only flow table entries with Hamming distance of 1 or 2 are found, and the content table entry tree height does not exceed the preset threshold, they are directly merged; if flow table entries with Hamming distance of both 1 and 2 are found, and the content table entry tree height does not exceed the preset threshold, a method with a higher degree of aggregation is selected for aggregation according to the predicted result, and the aggregated table entry is placed in the corresponding tuple according to its mask for further aggregation. Repeat the above operation until the content table entry tree height reaches the threshold.

[0049] like Figure 6 As shown, an embodiment of the present invention provides a content table item tree based on a binary tree structure, which is specifically constructed and used as follows:

[0050] For the two flow table items to be merged, if the Hamming distance between the matching fields is 2, first create a new root node to record a position where the bits between the matching fields of the two flow table items are different. Then, record the other position where the bits are different in the left and right child nodes of the root node respectively, and at the same time, set the content table item trees of the two flow table items to be merged as corresponding grandchild nodes, thereby forming a new content table item tree. In addition, if a flow table item is included in the aggregate table item, set its content table item tree as the corresponding leaf node. If the Hamming distance between the matching fields of the two items to be merged is 1, create a new root node to record the position where the bits are different, and set the content table item trees of the two flow table items as corresponding child nodes. During the flow table aggregation process, the above operations are repeated until the flow table items cannot be merged, and finally the content table item tree of the aggregate table item is constructed.

[0051] Reference Figure 7-10 , the above embodiment specifically includes the following operations:

[0052] a. OpenFlow packet forwarding operation

[0053] Figure 7 The OpenFlow packet forwarding process of this patent is described. When the OpenFlow switch receives a data packet in the network, it first parses the data packet header information and extracts the key fields of the flow. Then it searches in the matching sub-flow table according to the key fields. If the search is successful, it locates the corresponding content table item tree in the content sub-flow table according to the index value of the matching table item, and searches for the corresponding leaf node. If the search is successful, the correct action set is obtained, the data packet is forwarded, and the content fields such as the counter and timestamp of the corresponding item in the content table item tree are updated. If the search fails in the matching sub-flow table, it means that the data packet belongs to a new flow. The OpenFlow switch will package the header information of the data packet into a packet-in message and submit it to the controller to request the controller to issue new flow rules.

[0054] b. OpenFlow flow table insertion operation

[0055] Figure 8 The OpenFlow flow table insertion process of this patent is described. When the OpenFlow switch receives the flow-mod message with the ADD command sent by the SDN controller, it first extracts the flow rule information (such as matching fields, masks, action sets, etc.), creates a new flow table item, and performs the flow table item aggregation operation. First, search for the flow table item that contains it in the matching sub-flow table. If the search is successful, locate the content table item tree corresponding to the flow table item containing it, obtain the corresponding content table item tree, find the corresponding position in the content table item tree, and insert the flow table item as the corresponding leaf node. Otherwise, locate the corresponding tuple in the aggregation acceleration backup table according to the mask, and then find the flow table item that can be aggregated with the flow table item to be aggregated. If the search is successful, execute the content table item tree construction process operation, generate a new flow table item, and delete the merged flow table item in the matching sub-flow table and the aggregation acceleration backup table. If the search fails, the matching fields of the aggregation table item are stored in the matching sub-flow table and the aggregation acceleration backup table respectively. If all searches fail, that is, aggregation fails, the matching fields of the flow table entry are stored in the matching sub-flow table and the aggregation acceleration backup table, and the content fields are stored in the content sub-flow table.

[0056] c. Content table item tree construction operation

[0057] like Fig. 9The figure shows the process of building the content table item tree. When two flow items to be merged meet the aggregation conditions, first obtain the upper limit value threshold of the content table item tree layer number and the layer number tier of the highest content table item tree corresponding to the two flow items (the default tree height is 1 if there is only one action set). If the Hamming distance between the two matching fields is 1 and tier+1 is less than the set upper limit value of the content table item tree layer number, the two flow items are merged. Otherwise, determine whether tier+2 is less than the set upper limit value of the content table item tree layer number. If it is less, the two flow items are merged. The specific construction process is: if the Hamming distance of the matching field is 2, a new root node is created, and the first different bit position bp1 in the matching field of the two flow items is stored in it. Then, the second different bit position bp2 in the matching field of the two flow items is used as the left and right children of the root node. Finally, the content table item trees corresponding to the two flow items are used as child nodes corresponding to the left and right children. Then, other items in the tuple that can be included in the new aggregated table item are searched. If the search is successful, the included flow table item action set is stored in the leaf node corresponding to the aggregate table item content table item tree, and a new content table item tree is further generated. If the Hamming distance of the matching field is not 2, a new root node is created to record the different bit positions bp in the matching fields of the two flow table items, and the content table item trees corresponding to the two flow table items are used as the left and right child nodes of the root node.

[0058] d. OpenFlow flow table deletion operation

[0059] Fig.10 The OpenFlow flow table deletion process of this patent is described. When the OpenFlow switch receives a flow-mod message with a DELETE command sent by the SDN controller, it first extracts the flow rules, obtains the table item to be deleted, and searches for the table item to be deleted in the main matching flow table. If the search is successful and the matching table item is an aggregate table item, first locate the content table item tree corresponding to the aggregate table item. Then, search the content table item tree according to the matching field of the table item to be deleted. If the leaf node corresponding to the table item to be deleted is successfully found, delete the leaf node and locate its parent node. If the parent node has child nodes, the node needs to be deleted, and the corresponding matching table items in the matching sub-flow table and the aggregate acceleration backup table are updated. Keep backtracking to delete the parent node of the node and repeat the above operation until it has no child nodes.

[0060] If the search for the entry to be deleted in the matching subflow table is successful, and the matching entry is not an aggregate entry, the corresponding content entry in the content subflow table is deleted according to the index value of the entry to be deleted, and the matching entry in the matching subflow table and the aggregate acceleration backup table is deleted. If the search for the entry to be deleted in the matching subflow table fails, an error message is sent to the controller to report the failure to delete the flow rule.

[0061] like Fig.11 The example of the flow table aggregation method proposed in the present invention is shown, and the specific contents are as follows:

[0062] In the figure, the large solid box on the left represents a tuple, and the small solid box inside represents a flow item, and the flow item is represented in the form of <matching field → action set>. Among them, process ① represents the aggregation process of flow items, that is, flow items with a matching field Hamming distance of 2 or 1 can be aggregated into an aggregated item. Process ② represents the construction or synthesis of a content item tree during the aggregation process. The non-leaf nodes in the content item tree are used to represent the bit position of the aggregation. The leaf nodes represent the content field (including the action set). Only the action set is shown in the figure. Process ③ indicates that some items in the tuple are included in the aggregated item. At this time, the included items can be directly located at the leaf node of the aggregated item content item tree for further aggregation. Process ④ indicates that the aggregated item can be relocated through the mask, located in the corresponding tuple, and then further aggregated.

[0063] Compared with the prior art, the present invention designs a method for deep aggregation of OpenFlow flow tables, which divides the original flow table in OpenFlow into several tuples according to the mask, then performs double bit merging on the flow table items in each tuple, and constructs the content field (including action set) of the aggregated table item into a content table item tree according to the merged bit position, and then puts the aggregated table item into the corresponding tuple according to its mask for further aggregation, until it cannot be aggregated or the content table item tree reaches the upper limit. Further, the present invention provides a deep aggregation storage system for OpenFlow flow tables. The system uses the above-mentioned flow table deep aggregation method to compress the OpenFlow flow table, and strips out the content fields of all flow table items to construct a content table item tree and uses SRAM for separate storage, so that TCAM can accommodate the entire flow table. At the same time, the system limits the height of the content table item tree to ensure access and search speed. In addition, an aggregation acceleration sub-flow table is designed to specifically perform table item aggregation operations, thereby speeding up the flow table aggregation speed.

[0064] The above shows and describes 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 to the above embodiments. The above embodiments and descriptions are only for explaining the principles of the present invention. The present invention may be subject to various changes and improvements without departing from the spirit and scope of the present invention. These changes and improvements fall within the scope of the present invention. The scope of protection of the present invention is defined by the attached claims and their equivalents.

Claims

1. A method for deep aggregation of OpenFlow flow tables, which aggregates flow table items with different action sets by constructing a content table item tree and ensures the correctness of packet forwarding semantics; at the same time, the table item aggregation is not only for the case where the Hamming distance between matching fields is 1, but also extends to the case where the Hamming distance between matching fields is 2, thereby realizing double bit merging; the method first pre-judges the aggregation degree to determine the table item aggregation order, that is, prioritizes the aggregation of flow table items with matching field Hamming distance of 1 or 2, and then performs double bit merging, which specifically includes the following operations: a. OpenFlow flow table insertion operation When the OpenFlow switch receives the Flow_Mod message with the ADD command sent by the SDN controller, it needs to create a new flow table entry according to the message content and put it into the matching sub-flow table for aggregation; First, search for the flow table entry containing it in the matching sub-flow table. If the search is successful, locate the content table item tree corresponding to the flow table item, obtain the corresponding content table item tree, and search for the corresponding position in the content table item tree, and insert the flow table item as the corresponding leaf node; Otherwise, locate the corresponding tuple in the aggregation acceleration backup table according to the mask, and then search for the flow table entry that can be aggregated with the flow table entry to be aggregated; If the search is successful, the content table entry tree construction process is executed to generate a new flow table entry, and the merged flow table entry is deleted in the matching sub-flow table and the aggregation acceleration backup table; If the search fails, the matching fields of the aggregation table entry are stored in the matching sub-flow table and the aggregation acceleration backup table respectively; If all searches fail, that is, aggregation fails, the matching fields of the flow table entry are stored in the matching sub-flow table and the aggregation acceleration backup table, and the content fields are stored in the content sub-flow table; b. Content table item tree construction operation First, obtain the upper limit of the number of levels of the content table item tree and the tier of the highest level of the content table item tree corresponding to the two flow items; If the Hamming distance between the two matching fields is 1 and tier+1 is less than the upper limit of the number of levels of the content table entry tree, the two flow entries are merged; Otherwise, determine whether tier+2 is less than the upper limit of the number of content table entry tree layers. If so, merge the two flow table entries. If the Hamming distance of the matching field is 2, a new root node is created and the first different bit position bp in the matching field of the two flow table entries is 1 Store it, and then match the second different bit position bp in the field of the two flow table entries 2 As the left and right children of the root node, finally the content table item trees corresponding to the two flow table items are used as the child nodes of the corresponding left and right children; Search for other items in the tuple that can be included in the new aggregate item. If the search is successful, store the included flow item action set in the leaf node corresponding to the aggregate item content item tree, and further generate a new content item tree. If the Hamming distance of the matching field is not 2, a new root node is created to record the different bit positions bp in the matching fields of the two flow table entries, and the content table entry trees corresponding to the two flow table entries are used as the left and right child nodes of the root node.

2. According to claim 1, a method for deep aggregation of OpenFlow flow tables, It is characterized in that The action set tree based on the binary tree structure is designed as follows: non-leaf nodes record the merged bit positions when the table items are aggregated, while leaf nodes store the content fields containing the action set in the original table items, so as to determine the corresponding action set after the data packet successfully matches the aggregated table item.

3. According to claim 2, a method for deep aggregation of OpenFlow flow tables, It is characterized in that The OpenFlow flow table packet forwarding operation specifically includes the following steps: First, parse its header field and extract its matching field, then search for the matching sub-flow table; If the search is successful, the corresponding content table item tree in the content sub-flow table is located according to the index value of the matching table item, and the corresponding leaf node is searched; If the search is successful, the correct action set is obtained, the data packet is forwarded, and the counter and timestamp fields of the corresponding entry in the content entry tree are updated; If the search in the matching sub-flow table fails, it means that the data packet belongs to a new flow. The OpenFlow switch will package the header information of the data packet into a packet-in message and submit it to the controller to request the controller to issue new flow rules.

4. According to claim 2, a method for deep aggregation of OpenFlow flow tables, It is characterized in that The OpenFlow flow table deletion operation includes the following steps: First, extract the matching fields of the flow in the flow rule, and then search for the entry to be deleted in the main matching flow table; If the search is successful and the matching table item is an aggregate table item, first locate the content table item tree corresponding to the aggregate table item; Then, the content table item tree is searched according to the matching field of the table item to be deleted. If the leaf node corresponding to the table item to be deleted is successfully found, the leaf node is deleted and its parent node is located; If the parent node has a child node, the child node needs to be deleted, and the corresponding matching table entries in the matching subflow table and the aggregation acceleration backup table are updated; Keep backtracking and deleting the parent node of the node, repeating the above operation until it has no child nodes; If the search for the entry to be deleted in the matching subflow table is successful, and the matching entry is not an aggregate entry, the corresponding content entry in the content subflow table is deleted according to the index value of the entry to be deleted, and the matching entry in the matching subflow table and the aggregate acceleration backup table is deleted; If the search for the entry to be deleted in the matching sub-flow table fails, an error message is sent to the controller to report the failure of flow rule deletion.

Images