一种基于Openflow的事件并行控制器及其事件并行处理方法

摘要

本发明公开了一种基于Openflow的事件并行控制器及其事件并行处理方法，该方法将Openflow消息的收发与Openflow事件的处理相分离，利用额外的计算线程对Openflow事件处理进行加速。应用开启后的控制器将建立与交换机的链接，并将链接平均地分给多个I/O线程，每个链接上消息的收发由唯一的I/O线程处理。应用在接收Openflow消息后，触发对应的Openflow事件，并根据事件的类型产生对流对象和状态对象的处理任务，交由不同的线程进行处理。在流事件处理过程中，能够动态产生子任务，并由多个线程并行执行。对共享状态，使用唯一的状态线程进行处理。本发明方法相对于现有的Openflow事件的并行处理方法具有更好的性能可扩展性、以及更简单的数据访问方式。

说明书

技术领域

本发明涉及一种Openflow控制器，是指一种用软件定义网络领域Openflow控制器、以及对Openflow控制器内部事件的并行处理方法，特别涉及Openflow流事件处理过程内部的并行处理方法。 

背景技术

2008年，OpenFlow技术首次被提出。其思想是将传统网络设备中的数据转发和路由控制两个功能模块相分离，利用集中式的控制器通过标准化的接口对各种网络设备进行管理和配置。OpenFlow技术引起了业界的广泛关注，成为近年来十分热门的技术。由于Openflow技术为网络带来灵活的可编程性，因此该技术已被广泛的应用于校园网、广域网、移动网络以及数据中心网络等多种网络之中。 

在2009年12月31日公开的《OpenFlow Switch Specification》，Open Networking Foundation组织，在此文献的第4.1节介绍了OpenFlow消息的类型。Openflow消息包括有controller-to-switch（译：控制器向交换机传输的消息）、Asynchronous（译：异步消息）和Symmetric（译：对称消息）。其中异步消息中包括有Packet-in（译：流到达消息）、Flow-Removed（译：流移除消息）、Port-status（译：端口状态消息）和Error（译：错误消息）。 

在2013年3月29日的软件学报中公开了《基于OpenFlow的SDN技术》，左青云等人发表。文中公开了OpenFlow网络主要由OpenFlow交换机、控制器两部分组成。OpenFlow交换机根据流表来转发数据包，代表着数据转发平面；控制器通过全网络视图来实现管控功能，其控制逻辑表示控制平面。每个OpenFlow交换机的处理单元由流表构成，每个流表由许多流表项组成，流表项则代表转发规则。进入交换机的数据包通过查询流表来取得对应的操作。控制器通过维护网络视图（network view）来维护整个网络的基本信息，如拓扑、网络单元和提供的服务等。运行在控制器之上的应用程序通过调用网络视图中的全局数据，进而操作OpenFlow交换机来对整个网络进行管理和控制。 

Openflow技术的特点使得Openflow控制器端的处理效率成为网络能否正常运行的关键。原始单线程控制器的处理效率远远不能满足大规模Openflow网络的处理需求。因此，现有技术利用多线程，在控制器内部并行地处理Openflow事件，提高控制器的处理效率。 

但现有的Openflow事件并行处理方法，在利用众核环境对规模较大，行为复杂的Openflow网络进行控制时，存在处理性能的可扩展性问题：（1）流事件处理过程不支持并行操作，无法满足时间复杂度高的计算过程；（2）增加线程难以有效提高流事件的处理效率；（3）Openflow事件处理过程中，对共享数据的访问存在耦合，影响性能可扩展性。 

本发明针对上述问题，在Openflow控制器内部，针对Openflow事件，尤其是Openflow流事件，提出了一种新的事件并行控制器及其事件并行处理方法。 

发明内容

本发明的目的之一是提供一种基于Openflow的事件并行控制器，该控制器是利用众核环境，在大规模Openflow网络场景下，利用I/O线程并行地对Openflow消息进行收发，利用计算线程对Openflow事件的处理进行加速，增加流事件处理过程内部的并行支持，增强Openflow控制器的计算能力，提高性能可扩展性。 

本发明的目的之二是提出一种基于Openflow的事件并行处理方法，该方法使用多个线程并行地对Openflow消息进行收发；当收到Openflow消息后，触发对应的Openflow事件；针对流事件及其对应的处理方法，生成对该流事件的处理任务，由流－线程并行执行；针对其他类型事件及其对应的处理方法，生成针对共享状态的处理任务，由状态－线程并行执行；流事件的处理过程内部，可以动态的产生子任务，通过任务窃取的形式，多个线程可以并行地对同一个流事件进行处理。 

本发明是一种基于Openflow的事件并行控制器，该控制器包括有流处理模块（1）、状态处理模块（2）和Openflow消息分配控制模块（3）； 

Openflow消息分配控制模块（3）第一方面采用异步非阻塞IO模型从链接的接收缓冲区中接收Openflow交换机（4）发送的Openflow消息；所述Openflow消息中包括有Packet-in消息、Flow-Removed消息、Port-status消息和Error消息。 

Openflow消息分配控制模块（3）第二方面将流处理任务 ${\mathrm{TASK}}_{3-1}=\{{\mathrm{FA}}_{\mathrm{Packet}-\mathrm{in}}^{{\mathrm{FLOW}}_{\mathrm{Base}\_\mathrm{flow}}},{\mathrm{FA}}_{\mathrm{Flow}-\mathrm{Removed}}^{{\mathrm{FLOW}}_{\mathrm{Base}\_\mathrm{flow}}}\}$发送到流处理模块（1）的主线程本地任务队列Q_z中； 

所述流处理任务${\mathrm{TASK}}_{3-1}=\{{\mathrm{FA}}_{\mathrm{Packet}-\mathrm{in}}^{{\mathrm{FLOW}}_{\mathrm{Base}\_\mathrm{flow}}},{\mathrm{FA}}_{\mathrm{Flow}-\mathrm{Removed}}^{{\mathrm{FLOW}}_{\mathrm{Base}\_\mathrm{flow}}}\}$的获取是：（A）首先依据Packet-in消息触发Packet-in事件；然后根据Packet-in事件生成Base_flow结构的流对象FLOW_{Base_flow}＝{F₁,F₂,…,F_f}；最后根据Base_flow结构中start方法生成所述Packet-in事件对应的流处理任务（B）首先依据Flow-Removed消息触发Flow-Removed事件；然后根据Flow-Removed事件生成如表1中Base_flow结构的流对象FLOW_{Base_flow}＝{F₁,F₂,…,F_f}；最后根据Base_flow结构中start方法生成所述Flow-Removed事件对应的流处理任务 ${\mathrm{FA}}_{\mathrm{Flow}-\mathrm{Removed}}^{{\mathrm{FLOW}}_{\mathrm{Base}\_\mathrm{flow}}}.$

Openflow消息分配控制模块（3）第三方面将状态处理任务 ${\mathrm{TASK}}_{3-2}=\{{\mathrm{SA}}_{\mathrm{Port}-\mathrm{status}}^{{\mathrm{STATE}}_{\mathrm{Base}\_\mathrm{state}}},{\mathrm{SA}}_{\mathrm{Error}}^{{\mathrm{STATE}}_{\mathrm{Base}\_\mathrm{state}}}\}$发送到状态处理模块（2）的访问任务队列 $P_{\mathrm{state}}^{\mathrm{STAT}{E}_{\mathrm{Base}\_\mathrm{state}}}=\{P_1,P_2,...,P_s\}$中； 

所述状态处理任务${\mathrm{TASK}}_{3-2}=\{{\mathrm{SA}}_{\mathrm{Port}-\mathrm{status}}^{{\mathrm{STATE}}_{\mathrm{Base}\_\mathrm{state}}},{\mathrm{SA}}_{\mathrm{Error}}^{{\mathrm{STATE}}_{\mathrm{Base}\_\mathrm{state}}}\}$的获取是：（A）首先依据Port-status消息触发Port-status事件；然后根据Port-status事件生成Base_state结构的状态对象STATE_{Base_state}＝{S₁,S₂,…,S_s}的处理任务，即Port-status状态处理任务记为（B）首先依据Error消息触发Error事件；然后根据Error事件生成针对如表2中Base_state结构的状态对象STATE_{Base_state}＝{S₁,S₂,…,S_s}的处理任务，即Error状态处理任务记为 ${\mathrm{SA}}_{\mathrm{Error}}^{\mathrm{STAT}{E}_{\mathrm{Base}\_\mathrm{state}}}.$

Openflow消息分配控制模块（3）第四方面接收流处理模块（1）输出的controller-to-switch消息； 

Openflow消息分配控制模块（3）第五方面采用异步非阻塞IO模型从消息－线程TH₃＝{C₁,C₂,…,C_c}中所属的链接的发送缓冲区中向Openflow交换机（4）输出controller-to-switch消息。 

流处理模块（1）第一方面用于接收Openflow消息分配控制模块（3）输出的流处理任务${\mathrm{TASK}}_{3-1}=\{{\mathrm{FA}}_{\mathrm{Packet}-\mathrm{in}}^{{\mathrm{FLOW}}_{\mathrm{Base}\_\mathrm{flow}}},{\mathrm{FA}}_{\mathrm{Flow}-\mathrm{Removed}}^{{\mathrm{FLOW}}_{\mathrm{Base}\_\mathrm{flow}}}\};$

流处理模块（1）第二方面将${\mathrm{TASK}}_{3-1}=\{{\mathrm{FA}}_{\mathrm{Packet}-\mathrm{in}}^{{\mathrm{FLOW}}_{\mathrm{Base}\_\mathrm{flow}}},{\mathrm{FA}}_{\mathrm{Flow}-\mathrm{Removed}}^{{\mathrm{FLOW}}_{\mathrm{Base}\_\mathrm{flow}}}\}$保存到主线程本地任务队列Q_z中； 

流处理模块（1）第三方面将${\mathrm{TASK}}_{3-1}=\{{\mathrm{FA}}_{\mathrm{Packet}-\mathrm{in}}^{{\mathrm{FLOW}}_{\mathrm{Base}\_\mathrm{flow}}},{\mathrm{FA}}_{\mathrm{Flow}-\mathrm{Removed}}^{{\mathrm{FLOW}}_{\mathrm{Base}\_\mathrm{flow}}}\}$通过轮询的方式发送到计算线程本地任务队列中； 

流处理模块（1）第四方面执行${\mathrm{TASK}}_{3-1}=\{{\mathrm{FA}}_{\mathrm{Packet}-\mathrm{in}}^{{\mathrm{FLOW}}_{\mathrm{Base}\_\mathrm{flow}}},{\mathrm{FA}}_{\mathrm{Flow}-\mathrm{Removed}}^{{\mathrm{FLOW}}_{\mathrm{Base}\_\mathrm{flow}}}\}$中的具体任务；并动态生成对流对象FLOW_{Base_flow}＝{F₁,F₂,…,F_f}的处理任务，记为流对象子任务将所述添加到 $Q^{T{H}_1}=\{Q_1,Q_2,...,Q_a\}$中； 

流处理模块（1）第五方面执行${\mathrm{TASK}}_{3-1}=\{{\mathrm{FA}}_{\mathrm{Packet}-\mathrm{in}}^{{\mathrm{FLOW}}_{\mathrm{Base}\_\mathrm{flow}}},{\mathrm{FA}}_{\mathrm{Flow}-\mathrm{Removed}}^{{\mathrm{FLOW}}_{\mathrm{Base}\_\mathrm{flow}}}\}$中的具体任务；并动态生成对状态对象STATE_{Base_state}＝{S₁,S₂,…,S_s}的处理任务，记为状态对象子任务根据所述的的global属性的值，进行判断；如果global为true，则表示该状态为全局共享状态，则将所述的 给予状态处理模块（2），并等待状态处理模块（2）的任务完成消息STA_2-1；反之，如果global不为true，则表示该状态为局部共享状态，则流处理模块（1）中的产生所述的线程直接执行； 

流处理模块（1）第六方面通过任务窃取的方式进行计算线程的任务负载均衡。 

流处理模块（1）第七方面输出controller-to-switch消息给Openflow消息分配模块（3）。计算线程将需要输出的controller-to-switch消息同步地写入到消息－线程TH₃＝{C₁,C₂,…,C_c}中所属的链接的发送缓冲区中。 

状态处理模块（2）第一方面接收Openflow消息模块（3）发出的状态处理任务${\mathrm{TASK}}_{3-2}=\{{\mathrm{SA}}_{\mathrm{Port}-\mathrm{status}}^{{\mathrm{STATE}}_{\mathrm{Base}\_\mathrm{state}}},{\mathrm{SA}}_{\mathrm{Error}}^{{\mathrm{STATE}}_{\mathrm{Base}\_\mathrm{state}}}\},$并将 ${\mathrm{TASK}}_{3-2}=\{{\mathrm{SA}}_{\mathrm{Port}-\mathrm{status}}^{{\mathrm{STATE}}_{\mathrm{Base}\_\mathrm{state}}},{\mathrm{SA}}_{\mathrm{Error}}^{{\mathrm{STATE}}_{\mathrm{Base}\_\mathrm{state}}}\}$保存到状态对象STATE_{Base_state}＝{S₁,S₂,…,S_s}的访问任务队列中； 

状态处理模块（2）第二方面接收流处理模块（1）发出的状态处理任务 并将保存到状态对象STATE_{Base_state}＝{S₁,S₂,…,S_s}的访问任务队列中； 

状态处理模块（2）第三方面状态－线程TH₂＝{B₁,B₂,…,B_b}中的B₁从 中提取出属于B₁的访问任务队列 $P_{\mathrm{state}}^{B_1}=\{P_1,P_2,...,P_s\};$然后B₁通过轮询的方式执行$P_{\mathrm{state}}^{B_1}=\{P_1,P_2,...,P_s\}$中的任务；当执行完成后，向流处理模块1发送的任务完成消息

状态－线程TH₂＝{B₁,B₂,…,B_b}中的B₂从中提取出属于B₂的访问任务队列然后B₂通过轮询的方式执行 中的任务；当执行完成后，向流处理模块（1）发送的任务完成消息

状态－线程TH₂＝{B₁,B₂,…,B_b}中的B_b从中提取出属于B_b的访问任务队列然后B_b通过轮询的方式执行 中的任务；当执行完成后，向流处理模块1发送的任务完成消息

对于状态处理模块（2）第四方面向流处理模块（1）发送的任务完成消息集合记为${\mathrm{STA}}_{2-1}=\{{\mathrm{STA}}_{2-1}^{B_1},{\mathrm{STA}}_{2-1}^{B_2},...,{\mathrm{STA}}_{2-1}^{B_b}\}.$

本发明针对Openflow控制器的事件并行处理方法的优点在于： 

①本发明在Openflow控制器内部，将事件处理与消息收发相互分离，通过使用计算线程对Openflow事件进行并行处理，在流事件处理过程内部增加并行支持，可以有效地增强Openflow控制器的计算能力，提高控制器处理性能的可扩展性。 

②本发明使用状态－线程对共享状态进行唯一地处理，可以使用非互斥的方式对共享数据进行访问，简化了事件处理过程中对共享数据的访问，一定程度上提高了访问效率。 

附图说明

图1是本发明基于Openflow的事件并行控制器的结构框图。 

图2是本发明Openflow控制器内部的并行处理过程示意图。 

图3是基于switch程序的加速比对比图。 

图4是基于QPAS算法的加速比对比图。 

具体实施方式

下面将结合附图对本发明做进一步的详细说明。 

参见图1所示，本发明的一种基于Openflow的事件并行控制器，该控制器包括有流处理模块1、状态处理模块2和Openflow消息分配控制模块3；为了方便下文表述，本发明的控制器简称为POCA。本发明的POCA与现有Openflow控制器配合使用，且内嵌在Openflow网络体系结构中。 

在本发明中，POCA是对Openflow消息中的Packet-in（译：流到达消息）、Flow-Removed（译：流移除消息）、Port-status（译：端口状态消息）和Error（译：错误消息）进行关联的处理。 

在本发明中，Packet-in（译：流到达消息）对应的事件称为Packet-in事件；Flow-Removed（译：流移除消息）对应的事件称为Flow-Removed事件；Port-status（译：端口状态消息）对应的事件称为Port-status事件；Error（译：错误消息）对应的事件称为Error事件。 

在本发明中，Base_flow结构的流对象FLOW_{Base_flow}＝{F₁,F₂,…,F_f}中F₁表示第一种类型的流对象，F₂表示第二种类型的流对象，F_f表示最后一种类型的流对象，f为流对象的标识号，为了方便说明，下文将F_f也称为任意一种类型的流对象。 

在本发明中，Base_state结构的状态对象STATE_{Base_state}＝{S₁,S₂,…,S_s}中S₁表示第一种类型的状态对象，S₂表示第二种类型的状态对象，S_s表示最后一种类型的状态对象，s表示状态对象的标识号，为了方便说明，下文将S_s也称为任意一种类型的状态对象。任意一状态对象将对应有唯一的访问任务队列，则第一种类型的状态对象S₁对应的访问任务队列记为P₁（简称为第一个访问任务队列P₁），第二种类型的状态对象S₂对应的访问任务队列记为P₂（简称为第二个访问任务队列P₂），最后一种类型的状态对象S_s对应的访问任务队列记为P_s（简称为最后一个访问任务队列P_s）。访问任务队列采用集合表达形式为

在本发明中，流处理模块1中的线程记为流－线程TH₁＝{A₁,A₂,…,A_z,…,A_a}中A₁表示流处理模块1中的第一个线程，A₂表示流处理模块1中的第二个线程，A_z表示流处理模块1中的第z个线程，A_a表示流处理模块1中的最后一个线程，a表示流处理模块1中的线程标识号，为了方便说明，下文将A_a也称为任意一个线程。当流－线程TH₁＝{A₁,A₂,…,A_z,…,A_a}中的某一个线程A_z作为主线程后，则其余线程为计算线程TH₁＝{A₁,A₂,…,A_a}。任意一线程将对应有唯一的本地任务队列，则第一个线程A₁对应的本地任务队列记为Q₁（简称为第一个本地任务队列Q₁），第二个线程A₂对应的本地任务队列记为Q₂（简称为第二个本地任务队列Q₂），第z个线程A_z对应的本地任务队列记为Q_z（简称为第z个本地任务队列Q_z，也称为主线程本地任务队列Q_z），最后一个线程A_a对应的本地任务队列记为Q_a（简称为最后一个本地任务队列Q_a）。计算线程TH₁＝{A₁,A₂,…,A_a}所对应的本地任务队列集合记为$Q^{T{H}_1}=\{Q_1,Q_2,...,Q_a\}.$

在本发明中，状态处理模块2中的线程记为状态－线程TH₂＝{B₁,B₂,…,B_b}中B₁表示状态处理模块2中的第一个线程，B₂表示状态处理模块2中的第二个线程，B_b表示状态处理模块2中的最后一个线程，b表示状态处理模块2中的线程标识号，为了方便说明，下文将B_b也称为任意一个线程。对于状态处理模块2中的状态对象STATE_{Base_state}＝{S₁,S₂,…,S_s}是平均分配在状态－线程TH₂＝{B₁,B₂,…,B_b}上的，则任意一状态－线程B_b上将处理多个访问任务队列，被所述的状态－线程B_b处理的访问任务队列记为$P_{\mathrm{state}}^{B_b}=\{P_1,P_2,...,P_s\},$且$P_{\mathrm{state}}^{B_b}\in P_{\mathrm{state}}^{\mathrm{STAT}{E}_{\mathrm{Base}\_\mathrm{state}}};$任意一访问任务队列P_s将对应有唯一一个线程B_b。 

在本发明中，Openflow消息分配控制模块3中的线程记为消息－线程TH₃＝{C₁,C₂,…,C_c}中C₁表示Openflow消息分配控制模块3中的第一个线程，C₂表示Openflow消息分配控制模块3中的第二个线程，C_c表示Openflow消息分配控制模块3中的最后一个线程，c表示Openflow消息分配控制模块3中的线程标识号，为了方便说明，下文将C_c也称为任意一个线程。 

Openflow消息分配控制模块3与多个Openflow交换机4的链接记为SV表示Openflow控制器，SW表示Openflow交换机集合，SW＝{D₁,D₂,…,D_d}中D₁表示第一个Openflow交换机，D₂表示第二个 Openflow交换机，D_d表示最后一个Openflow交换机，d表示Openflow交换机的标识号，为了方便说明，下文将D_d也称为任意一个Openflow交换机。第一条链接记为第二条链接记为最后一条链接记为（也称为任意一一条链接），${\mathrm{CON}}_{\mathrm{SW}}^{\mathrm{SV}}=\{{\mathrm{CON}}_{D_1}^{\mathrm{SV}},{\mathrm{CON}}_{D_2}^{\mathrm{SV}},...,{\mathrm{CON}}_{D_d}^{\mathrm{SV}}\}.$对于Openflow消息分配控制模块3与Openflow交换机4之间的链接是平均分配在消息－线程TH₃＝{C₁,C₂,…,C_c}上的，且任意一一条链接将对应有唯一一个线程C_c。 

（一）Openflow消息分配控制模块3 

参见图1所示，Openflow消息分配控制模块3第一方面采用异步非阻塞IO模型从链接的接收缓冲区中接收Openflow交换机4发送的Openflow消息； 

所述Openflow消息中包括有Packet-in消息、Flow-Removed消息、Port-status消息和Error消息。 

Openflow消息分配控制模块3第二方面将流处理任务 ${\mathrm{TASK}}_{3-1}=\{{\mathrm{FA}}_{\mathrm{Packet}-\mathrm{in}}^{{\mathrm{FLOW}}_{\mathrm{Base}\_\mathrm{flow}}},{\mathrm{FA}}_{\mathrm{Flow}-\mathrm{Removed}}^{{\mathrm{FLOW}}_{\mathrm{Base}\_\mathrm{flow}}}\}$发送到流处理模块1的主线程本地任务队列Q_z中； 

在本发明中，所述流处理任务${\mathrm{TASK}}_{3-1}=\{{\mathrm{FA}}_{\mathrm{Packet}-\mathrm{in}}^{{\mathrm{FLOW}}_{\mathrm{Base}\_\mathrm{flow}}},{\mathrm{FA}}_{\mathrm{Flow}-\mathrm{Removed}}^{{\mathrm{FLOW}}_{\mathrm{Base}\_\mathrm{flow}}}\}$的获取是：（A）首先依据Packet-in消息触发Packet-in事件；然后根据Packet-in事件生成如表1中Base_flow结构的流对象FLOW_{Base_flow}＝{F₁,F₂,…,F_f}；最后根据Base_flow结构中start方法生成所述Packet-in事件对应的流处理任务 （B）首先依据Flow-Removed消息触发Flow-Removed事件；然后根据Flow-Removed事件生成如表1中Base_flow结构的流对象FLOW_{Base_flow}＝{F₁,F₂,…,F_f}；最后根据Base_flow结构中start方法生成所述Flow-Removed事件对应的流处理任务

在本发明中，Base_flow结构的流对象FLOW_{Base_flow}＝{F₁,F₂,…,F_f}中F₁表示第一种类型的流对象，F₂表示第二种类型的流对象，F_f表示最后一种类型的流对象，f为流对象的标识号，为了方便说明，下文将F_f也称为任意一种类型的流对象。 

表1Base_flow类 

Openflow消息分配控制模块3第三方面将状态处理任务 ${\mathrm{TASK}}_{3-2}=\{{\mathrm{SA}}_{\mathrm{Port}-\mathrm{status}}^{{\mathrm{STATE}}_{\mathrm{Base}\_\mathrm{state}}},{\mathrm{SA}}_{\mathrm{Error}}^{{\mathrm{STATE}}_{\mathrm{Base}\_\mathrm{state}}}\}$发送到状态处理模块2的访问任务队列 $P_{\mathrm{state}}^{\mathrm{STAT}{E}_{\mathrm{Base}\_\mathrm{state}}}=\{P_1,P_2,...,P_s\}$中； 

在本发明中，所述状态处理任务${\mathrm{TASK}}_{3-2}=\{{\mathrm{SA}}_{\mathrm{Port}-\mathrm{status}}^{{\mathrm{STATE}}_{\mathrm{Base}\_\mathrm{state}}},{\mathrm{SA}}_{\mathrm{Error}}^{{\mathrm{STATE}}_{\mathrm{Base}\_\mathrm{state}}}\}$的获取是：（A）首先依据Port-status消息触发Port-status事件；然后根据Port-status事件生成针对如表2中Base_state结构的状态对象STATE_{Base_state}＝{S₁,S₂,…,S_s}的处理任务，即Port-status状态处理任务记为 （B）首先依据Error消息触发Error事件；然后根据Error事件生成针对如表2中Base_state结构的状态对象STATE_{Base_state}＝{S₁,S₂,…,S_s}的处理任务，即Error状态处理任务记为

表2Base_state类 

Openflow消息分配控制模块3第四方面接收流处理模块1输出的controller-to-switch消息； 

Openflow消息分配控制模块3第五方面采用异步非阻塞IO模型从消息－线程TH₃＝{C₁,C₂,…,C_c}中所属的链接的发送缓冲区中向Openflow交换机4输出controller-to-switch消息。 

（二）流处理模块1 

参见图1所示，流处理模块1第一方面用于接收Openflow消息分配控制模块3输出的流处理任务${\mathrm{TASK}}_{3-1}=\{{\mathrm{FA}}_{\mathrm{Packet}-\mathrm{in}}^{{\mathrm{FLOW}}_{\mathrm{Base}\_\mathrm{flow}}},{\mathrm{FA}}_{\mathrm{Flow}-\mathrm{Removed}}^{{\mathrm{FLOW}}_{\mathrm{Base}\_\mathrm{flow}}}\};$

第二方面将${\mathrm{TASK}}_{3-1}=\{{\mathrm{FA}}_{\mathrm{Packet}-\mathrm{in}}^{{\mathrm{FLOW}}_{\mathrm{Base}\_\mathrm{flow}}},{\mathrm{FA}}_{\mathrm{Flow}-\mathrm{Removed}}^{{\mathrm{FLOW}}_{\mathrm{Base}\_\mathrm{flow}}}\}$保存到主线程本地任务队列Q_z中； 

第三方面将${\mathrm{TASK}}_{3-1}=\{{\mathrm{FA}}_{\mathrm{Packet}-\mathrm{in}}^{{\mathrm{FLOW}}_{\mathrm{Base}\_\mathrm{flow}}},{\mathrm{FA}}_{\mathrm{Flow}-\mathrm{Removed}}^{{\mathrm{FLOW}}_{\mathrm{Base}\_\mathrm{flow}}}\}$通过轮询的方式发送到流处理模块1的计算线程本地任务队列中； 

第四方面执行${\mathrm{TASK}}_{3-1}=\{{\mathrm{FA}}_{\mathrm{Packet}-\mathrm{in}}^{{\mathrm{FLOW}}_{\mathrm{Base}\_\mathrm{flow}}},{\mathrm{FA}}_{\mathrm{Flow}-\mathrm{Removed}}^{{\mathrm{FLOW}}_{\mathrm{Base}\_\mathrm{flow}}}\}$中的具体任务；并动态生成对流对象FLOW_{Base_flow}＝{F₁,F₂,…,F_f}的处理任务，记为流对象子任务 将所述添加到$Q^{T{H}_1}=\{Q_1,Q_2,...,Q_a\}$中； 

第五方面执行${\mathrm{TASK}}_{3-1}=\{{\mathrm{FA}}_{\mathrm{Packet}-\mathrm{in}}^{{\mathrm{FLOW}}_{\mathrm{Base}\_\mathrm{flow}}},{\mathrm{FA}}_{\mathrm{Flow}-\mathrm{Removed}}^{{\mathrm{FLOW}}_{\mathrm{Base}\_\mathrm{flow}}}\}$中的具体任务；并动态生成对状态对象STATE_{Base_state}＝{S₁,S₂,…,S_s}的处理任务，记为状态对象子任务 根据所述的的global属性（如表2第4行所示） 的值，进行判断；如果global为true，则表示该状态为全局共享状态，则将所述的 给予状态处理模块2，并等待状态处理模块2的任务完成消息STA_2-1；反之，如果global不为true，则表示该状态为局部共享状态，则流处理模块1中的产生所述的线程直接执行； 

第六方面流处理模块1中的计算线程通过任务窃取的方式，进行负载均衡。 

所述“任务窃取方式”的相关公开信息： 

文章名称：Scheduling multithreaded computations by work stealing 

作者：Robert D.Blumofe Univ.of Texas at Austin,Austin； 

Charles E.Leiserson MIT Lab for Computer Science,Cambridge,MA； 

发表信息：Journal of the ACM(JACM)JACM Homepage archive 

Volume46Issue5,Sept.1999，Pages720-748，ACM New York,NY,USA。 

在本发明中，当流处理模块1接收到状态处理模块2输出的任务完成消息 之后，首先判断是否存在计算线程等待该消息，如果存在，则令等待消息${\mathrm{STA}}_{2-1}=\{{\mathrm{STA}}_{2-1}^{B_1},{\mathrm{STA}}_{2-1}^{B_2},...,{\mathrm{STA}}_{2-1}^{B_b}\}$的计算线程继续执行；否则，忽略该消息。 

流处理模块1第七方面输出controller-to-switch消息给Openflow消息分配模块3。在本发明中，计算线程将需要输出的controller-to-switch消息同步地写入到消息－线程TH₃＝{C₁,C₂,…,C_c}中所属的链接的发送缓冲区中。 

（三）状态处理模块2 

参见图1所示，状态处理模块2第一方面接收Openflow消息模块3发出的状态处理任务${\mathrm{TASK}}_{3-2}=\{{\mathrm{SA}}_{\mathrm{Port}-\mathrm{status}}^{{\mathrm{STATE}}_{\mathrm{Base}\_\mathrm{state}}},{\mathrm{SA}}_{\mathrm{Error}}^{{\mathrm{STATE}}_{\mathrm{Base}\_\mathrm{state}}}\},$并将 ${\mathrm{TASK}}_{3-2}=\{{\mathrm{SA}}_{\mathrm{Port}-\mathrm{status}}^{{\mathrm{STATE}}_{\mathrm{Base}\_\mathrm{state}}},{\mathrm{SA}}_{\mathrm{Error}}^{{\mathrm{STATE}}_{\mathrm{Base}\_\mathrm{state}}}\}$保存到状态对象STATE_{Base_state}＝{S₁,S₂,…,S_s}的访问任务队列中； 

状态处理模块2第二方面接收流处理模块1发出的状态处理任务 并将保存到状态对象STATE_{Base_state}＝{S₁,S₂,…,S_s}的访问任务队列中； 

状态处理模块2第三方面状态－线程TH₂＝{B₁,B₂,…,B_b}中的B₁从 中提取出属于B₁的访问任务队列 $P_{\mathrm{state}}^{B_1}=\{P_1,P_2,...,P_s\};$然后B₁通过轮询的方式执行$P_{\mathrm{state}}^{B_1}=\{P_1,P_2,...,P_s\}$中的任务；当执行完成后，向流处理模块1发送的任务完成消息

状态－线程TH₂＝{B₁,B₂,…,B_b}中的B₂从中提取出属于B₂的访问任务队列然后B₂通过轮询的方式执行 中的任务；当执行完成后，向流处理模块1发送的任务完成消息

状态－线程TH₂＝{B₁,B₂,…,B_b}中的B_b从中提取出属于B_b的访问任务队列然后B_b通过轮询的方式执行 中的任务；当执行完成后，向流处理模块1发送的任务完成消息

对于状态处理模块2第四方面向流处理模块1发送的任务完成消息集合记为 ${\mathrm{STA}}_{2-1}=\{{\mathrm{STA}}_{2-1}^{B_1},{\mathrm{STA}}_{2-1}^{B_2},...,{\mathrm{STA}}_{2-1}^{B_b}\}.$

参见图2所示，采用本发明设计的基于Openflow的事件并行控制器进行Openflow事件的并行处理，其包括下列并行处理步骤： 

步骤一：Openflow消息的并行收发，触发对应Openflow事件 

在本发明的基于Openflow的事件并行控制器内每个交换机存在唯一的链接。 

进行链接建立过程中，消息－线程TH₃＝{C₁,C₂,…,C_c}中的第一个线程C₁负责对Openflow交换机SW＝{D₁,D₂,…,D_d}的链接请求进行监听。当收到链接请求后，建立链接${\mathrm{CON}}_{\mathrm{SW}}^{\mathrm{SV}}=\{{\mathrm{CON}}_{D_1}^{\mathrm{SV}},{\mathrm{CON}}_{D_2}^{\mathrm{SV}},...,{\mathrm{CON}}_{D_d}^{\mathrm{SV}}\},$并将链接${\mathrm{CON}}_{\mathrm{SW}}^{\mathrm{SV}}$平均地分配给消息－线程TH₃。任意一一条链接由唯一一个线程C_c进行处理。 

Openflow消息接收过程中，消息－线程TH₃＝{C₁,C₂,…,C_c}采用异步非阻塞IO模型从链接的接收缓冲区中接收Openflow交换机SW＝{D₁,D₂,…,D_d}发送的 Openflow消息。依据Packet-in消息触发Packet-in事件；依据Flow-Removed消息触发Flow-Removed事件；依据Port-status消息触发Port-status事件；依据Error消息触发Error事件。 

Openflow消息发送过程中，消息－线程TH₃＝{C₁,C₂,…,C_c}采用异步非阻塞IO模型从消息－线程TH₃＝{C₁,C₂,…,C_c}中所属的链接的发送缓冲区中向Openflow交换机SW＝{D₁,D₂,…,D_d}输出controller-to-switch消息。对链接的发送缓冲区的操作需要进行同步。 

在本发明中，Openflow消息的并行收发利用了多个消息－线程并行地对Openflow消息进行收发，每个Openflow交换机链接由唯一的消息－线程进行处理，消息－线程之间不存在互斥。因此，可以最大限度地提高Openflow消息收发效率。另外，利用异步非阻塞IO模型能够减小消息收发过程与消息处理过程的干扰，从而进一步提高了消息收发效率。 

步骤二：Openflow事件的并行处理 

针对Packet-in事件和Flow-Removed事件，首先生成如表1中Base_flow结构的流对象FLOW_{Base_flow}＝{F₁,F₂,…,F_f}，然后根据Base_flow结构中start方法生成流处理任务${\mathrm{TASK}}_{3-1}=\{{\mathrm{FA}}_{\mathrm{Packet}-\mathrm{in}}^{{\mathrm{FLOW}}_{\mathrm{Base}\_\mathrm{flow}}},{\mathrm{FA}}_{\mathrm{Flow}-\mathrm{Removed}}^{{\mathrm{FLOW}}_{\mathrm{Base}\_\mathrm{flow}}}\},$最后将该任务 ${\mathrm{TASK}}_{3-1}=\{{\mathrm{FA}}_{\mathrm{Packet}-\mathrm{in}}^{{\mathrm{FLOW}}_{\mathrm{Base}\_\mathrm{flow}}},{\mathrm{FA}}_{\mathrm{Flow}-\mathrm{Removed}}^{{\mathrm{FLOW}}_{\mathrm{Base}\_\mathrm{flow}}}\}$发送到流处理模块1中的主线程本地任务队列Q_z中； 

针对流处理任务${\mathrm{TASK}}_{3-1}=\{{\mathrm{FA}}_{\mathrm{Packet}-\mathrm{in}}^{{\mathrm{FLOW}}_{\mathrm{Base}\_\mathrm{flow}}},{\mathrm{FA}}_{\mathrm{Flow}-\mathrm{Removed}}^{{\mathrm{FLOW}}_{\mathrm{Base}\_\mathrm{flow}}}\}$在流处理模块1中，主线程A_z将${\mathrm{TASK}}_{3-1}=\{{\mathrm{FA}}_{\mathrm{Packet}-\mathrm{in}}^{{\mathrm{FLOW}}_{\mathrm{Base}\_\mathrm{flow}}},{\mathrm{FA}}_{\mathrm{Flow}-\mathrm{Removed}}^{{\mathrm{FLOW}}_{\mathrm{Base}\_\mathrm{flow}}}\}$通过轮询的方式发送到流处理模块1的计算线程本地任务队列中；计算线程TH₁＝{A₁,A₂,…,A_a}执行${\mathrm{TASK}}_{3-1}=\{{\mathrm{FA}}_{\mathrm{Packet}-\mathrm{in}}^{{\mathrm{FLOW}}_{\mathrm{Base}\_\mathrm{flow}}},{\mathrm{FA}}_{\mathrm{Flow}-\mathrm{Remved}}^{{\mathrm{FLOW}}_{\mathrm{Base}\_\mathrm{flow}}}\}$中的具体任务；并动态生成流对象子任务将所述添加到 $Q^{T{H}_1}=\{Q_1,Q_2,...,Q_a\}$中； 

计算线程TH₁＝{A₁,A₂,…,A_a}执行${\mathrm{TASK}}_{3-1}=\{{\mathrm{FA}}_{\mathrm{Packet}-\mathrm{in}}^{{\mathrm{FLOW}}_{\mathrm{Base}\_\mathrm{flow}}},{\mathrm{FA}}_{\mathrm{Flow}-\mathrm{Removed}}^{{\mathrm{FLOW}}_{\mathrm{Base}\_\mathrm{flow}}}\}$中的具体任务；并动态生成状态对象子任务根据所述的 的global属性（如表2第4行所示）的值，进行判断；如果global 为true，则表示该状态为全局共享状态，则将所述的给予状态处理模块2，并等待状态处理模块2的任务完成消息STA_2-1；反之，如果global不为true，则表示该状态为局部共享状态，则流处理模块1中的产生所述的线程直接执行；流处理模块1中的计算线程通过任务窃取的方式，进行负载均衡。 

针对Port-status事件和Error事件，首先生成针对如表2中Base_state结构的状态对象STATE_{Base_state}＝{S₁,S₂,…,S_s}的处理任务 ${\mathrm{TASK}}_{3-2}=\{{\mathrm{SA}}_{\mathrm{Port}-\mathrm{status}}^{{\mathrm{STATE}}_{\mathrm{Base}\_\mathrm{state}}},{\mathrm{SA}}_{\mathrm{Error}}^{{\mathrm{STATE}}_{\mathrm{Base}\_\mathrm{state}}}\},$然后将该任务 ${\mathrm{TASK}}_{3-2}=\{{\mathrm{SA}}_{\mathrm{Port}-\mathrm{status}}^{{\mathrm{STATE}}_{\mathrm{Base}\_\mathrm{state}}},{\mathrm{SA}}_{\mathrm{Error}}^{{\mathrm{STATE}}_{\mathrm{Base}\_\mathrm{state}}}\}$发送到状态处理模块2的访问任务队列 $P_{\mathrm{state}}^{{\mathrm{STATE}}_{\mathrm{Base}\_\mathrm{state}}}=\{P_1{,P}_2,...,P_s\}$中。 

针对任务${\mathrm{TASK}}_{3-2}=\{{\mathrm{SA}}_{\mathrm{Port}-\mathrm{status}}^{{\mathrm{STATE}}_{\mathrm{Base}\_\mathrm{state}}},{\mathrm{SA}}_{\mathrm{Error}}^{{\mathrm{STATE}}_{\mathrm{Base}\_\mathrm{state}}}\}$和任务${\mathrm{TASK}}_{{\mathrm{STATE}}_{\mathrm{Base}\_\mathrm{state}}}^{\mathrm{sub}},$在状态处理模块2中，状态－线程TH₂＝{B₁,B₂,…,B_b}中的B₁从 中提取出属于B₁的访问任务队列 $P_{\mathrm{state}}^{B_1}=\{P_1,P_2,...,P_s\};$然后B₁通过轮询的方式执行$P_{\mathrm{state}}^{B_1}=\{P_1,P_2,...,P_s\};$中的任务；当执行完成后，向流处理模块1发送的任务完成消息状态－线程TH₂＝{B₁,B₂,…,B_b}中的B₂从中提取出属于B₂的访问任务队列然后B₂通过轮询的方式执行 中的任务；当执行完成后，向流处理模块1发送的任务完成消息状态－线程TH₂＝{B₁,B₂,…,B_b}中的B_b从 中提取出属于B_b的访问任务队列 $P_{\mathrm{state}}^{B_b}=\{P_1,P_2,...,P_s\};$然后B_b通过轮询的方式执行$P_{\mathrm{state}}^{B_b}=\{P_1,P_2,...,P_s\}$中的任务；当执行完成后，向流处理模块1发送的任务完成消息

在本发明中，通过接收Openflow消息后，触发对应的Openflow事件，并根据事件的类型产生对流对象和状态对象的处理任务，交由不同的线程进行并行处理。在流事件处理过程中，能够动态产生子任务，利用任务窃取的方式由多个计算线程并行地处理，提高流事件处理效率。控制器中每一个共享状态由唯一的状态线程进行处理，不仅简化了对共享状态的访问，而且可以在一定程度上提高计算线程对流事件的处理效率。利用本发明中的事件并行处理方法可以使Openflow控制器具有更好的性能可扩展性。 

验证实施例

基于Openflow消息的事件并行处理系统POCA，在执行计算量小的switch程序时，相比其他Openflow控制器，随着线程个数的增多，当线程个数大于8时，POCA具有更高的加速比。原因是每个IO线程处理各自所属的交换机链接，相互之间不存在干扰，因此提高了处理性能。请参见图3所示的基于switch程序的加速比对比图。 

参见图4所示的基于QPAS算法的加速比对比图。在处理计算量较大的QPAS算法时，随着线程个数的增多，与NOX相比，POCA具有更高的加速比。原因在于：POCA在事件处理过程内部通过计算线程进行并行加速，提高了每个事件的处理效率，进而提高了整体的处理效率。 

本发明公开了一种基于Openflow的事件并行控制器及其事件并行处理方法，该方法将Openflow消息的收发与Openflow事件的处理相分离，利用额外的计算线程对Openflow事件处理进行加速。应用开启后的控制器将建立与交换机的链接，并将链接平均地分给多个I/O线程，每个链接上消息的收发由唯一的I/O线程处理。应用在接收Openflow消息后，触发对应的Openflow事件，并根据事件的类型产生对流对象和状态对象的处理任务，交由不同的线程进行处理。在流事件处理过程中，能够动态产生子任务，并由多个线程并行执行。对共享状态，使用唯一的状态线程进行处理。本发明方法相对于现有的Openflow事件的并行处理方法具有更好的性能可扩展性、以及更简单的数据访问方式。