CN103677760B - A kind of event concurrency controller based on Openflow and event concurrency disposal route thereof - Google Patents

Abstract

The invention discloses a kind of event concurrency controller based on Openflow and event concurrency disposal route thereof, the process of the transmitting-receiving of Openflow message and Openflow event is separated by the method, utilizes extra computational threads to accelerate Openflow event handling.Application open after controller will set up and the linking of switch, and link is given fifty-fifty multiple I/O thread, each transmitting-receiving chaining message is by unique I/O thread process.Be applied in after receiving Openflow message, trigger corresponding Openflow event, and produce the Processing tasks to flow object and status object according to the type of event, transfer to different threads to process.In stream event handler procedure, dynamically can produce subtask, and be performed by multiple thread parallel.To shared state, unique state thread is used to process.The inventive method has better performance extensibility and simpler data access mode relative to the method for parallel processing of existing Openflow event.

Description

A kind of event concurrency controller based on Openflow and event concurrency disposal route thereof

Technical field

The present invention relates to a kind of Openflow controller, refer to a kind of software defined network field Openflow controller and the method for parallel processing to Openflow controller internal event, particularly Openflow flows the method for parallel processing of event handler procedure inside.

Background technology

2008, OpenFlow technology was suggested first.Its thought is separated at the data retransmission in legacy network devices and route test two functional modules, utilizes centralized controller to be managed by standardized interface the various network equipment and configure.OpenFlow technology causes the extensive concern of industry, becomes technology very popular in recent years.Because Openflow technology is that network brings programmability flexibly, therefore this technology has been widely used among the multiple network such as campus network, wide area network, mobile network and data center network.

Disclosed in 31 days Dec in 2009 " OpenFlowSwitchSpecification ", OpenNetworkingFoundation organizes, and describes the type of OpenFlow message at this document Section 4.1.Openflow message includes controller-to-switch(and translates: the message that controller transmits to switch), Asynchronous(translates: asynchronous message) and Symmetric(translate: symmetric message).Wherein include Packet-in(in asynchronous message to translate: flow to and reach message), Flow-Removed(translates: drift except message), Port-status(translates: port status message) and Error(translate: error message).

Disclose in the Journal of Software on March 29th, 2013 " the SDN technology based on OpenFlow ", the people such as left high official position deliver.OpenFlow network is disclosed primarily of OpenFlow switch, controller two parts composition in literary composition.OpenFlow switch carrys out forwarding data bag according to stream table, represents data retransmission plane; Controller realizes management and control function by whole network view, and its steering logic represents control plane.The processing unit of each OpenFlow switch is formed by flowing table, and each stream table is made up of many stream list items, and stream list item then represents and forwards rule.The packet entering switch obtains corresponding operation by inquiry stream table.Controller safeguards the essential information of whole network by maintaining network view (networkview), as topology, network element and the service etc. that provides.Operate in application program on controller by calling the global data in network view, and then operation OpenFlow switch manages to whole network and controls.

The key that can the feature of Openflow technology make the treatment effeciency of Openflow controller end become network normally to run.The treatment effeciency of original single-threaded controller can not meet the processing demands of extensive Openflow network far away.Therefore, prior art utilizes multithreading, processes Openflow event concurrently in controller inside, improves the treatment effeciency of controller.

But existing Openflow event concurrency disposal route, utilizing many nuclear environments to larger, when the Openflow network of behavior complexity controls, there is the scalability problem of handling property: (1) stream event handler procedure does not support parallel work-flow, cannot meet the computation process that time complexity is high; (2) increase thread and be difficult to the treatment effeciency effectively improving stream event; (3), in Openflow event handler procedure, coupling is existed to the access of shared data, affects performance extensibility.

The present invention is directed to the problems referred to above, inner at Openflow controller, for Openflow event, especially Openflow flows event, proposes a kind of new event concurrency controller and event concurrency disposal route thereof.

Summary of the invention

An object of the present invention is to provide a kind of event concurrency controller based on Openflow, this controller utilizes many nuclear environments, under extensive Openflow network scenarios, Openflow message is received and dispatched with utilizing I/O thread parallel, the process of computational threads to Openflow event is utilized to accelerate, increase the parallel support of stream event handler procedure inside, strengthen the computing power of Openflow controller, improve performance extensibility.

Two of object of the present invention proposes a kind of event concurrency disposal route based on Openflow, and the method is received and dispatched Openflow message with using multiple thread parallel; After receiving Openflow message, trigger corresponding Openflow event; For stream event and the disposal route of correspondence thereof, generate the Processing tasks to this stream event, performed by stream-thread parallel; For the disposal route of other types event and correspondence thereof, generate the Processing tasks for shared state, performed by state-thread parallel; The processing procedure of stream event is inner, and can produce subtask dynamically, by the form of task stealing, multiple thread can process same stream event concurrently.

The present invention is a kind of event concurrency controller based on Openflow, and this controller includes stream processing module (1), status processing module (2) and Openflow message and distributes control module (3);

Openflow message distribution control module (3) first aspect employing asynchronous and unblock IO model receives the Openflow message that Openflow switch (4) sends from the reception buffer zone of link; Packet-in message, Flow-Removed message, Port-status message and Error message is included in described Openflow message.

Openflow message distributes control module (3) second aspect will flow Processing tasks ${\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}}}\}$ Be sent to the local task queue Q of main thread of stream processing module (1) _zin;

Described stream Processing tasks ${\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}}}\}$ Acquisition be: (A) is first according to Packet-in message trigger Packet-in event; Then the flow object FLOW of Base_flow structure is generated according to Packet-in event _{base_flow}={ F ₁, F ₂..., F _f; Finally generate stream Processing tasks corresponding to described Packet-in event according to start method in Base_flow structure (B) first according to Flow-Removed message trigger Flow-Removed event; Then the flow object FLOW as Base_flow structure in table 1 is generated according to Flow-Removed event _{base_flow}={ F ₁, F ₂..., F _f; Finally generate stream Processing tasks corresponding to described Flow-Removed event according to start method in Base_flow structure ${\mathrm{FA}}_{\mathrm{Flow}-\mathrm{Removed}}^{{\mathrm{FLOW}}_{\mathrm{Base}\_\mathrm{flow}}}.$

Openflow message distributes control module (3) third aspect by state processing tasks ${\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}}}\}$ Be sent to the access task queue of status processing module (2) $P_{\mathrm{state}}^{\mathrm{STAT}{E}_{\mathrm{Base}\_\mathrm{state}}}=\{P_1,P_2,...,P_s\}$ In;

Described state processing tasks ${\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}}}\}$ Acquisition be: (A) is first according to Port-status message trigger Port-status event; Then the status object STATE of Base_state structure is generated according to Port-status event _{base_state}={ S ₁, S ₂..., S _sprocessing tasks, namely Port-status state processing tasks is designated as (B) first according to Error message trigger Error event; Then the status object STATE for Base_state structure in such as table 2 is generated according to Error event _{base_state}={ S ₁, S ₂..., S _sprocessing tasks, namely Error state processing tasks is designated as ${\mathrm{SA}}_{\mathrm{Error}}^{\mathrm{STAT}{E}_{\mathrm{Base}\_\mathrm{state}}}.$

Openflow message is distributed control module (3) fourth aspect and is received the controller-to-switch message flowing processing module (1) and export;

Openflow message is distributed control module (3) the 5th aspect and is adopted asynchronous and unblock IO model from message-thread TH ₃={ C ₁, C ₂..., C _cin belonging to link transmission buffer zone in export controller-to-switch message to Openflow switch (4).

The stream Processing tasks that stream processing module (1) first aspect exports for receiving Openflow message distribution control module (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}}}\};$

Stream processing module (1) second aspect will ${\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}}}\}$ Be saved in the local task queue Q of main thread _zin;

Stream processing module (1) third aspect will ${\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}}}\}$ The local task queue of computational threads is sent to by the mode of poll in;

Stream processing module (1) fourth aspect performs ${\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}}}\}$ In specific tasks; And dynamically generate flow object FLOW _{base_flow}={ F ₁, F ₂..., F _fprocessing tasks, be designated as flow object subtask described in inciting somebody to action add to $Q^{T{H}_1}=\{Q_1,Q_2,...,Q_a\}$ In;

Stream processing module (1) the 5th aspect performs ${\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}}}\}$ In specific tasks; And dynamically generate status object STATE _{base_state}={ S ₁, S ₂..., S _sprocessing tasks, be designated as status object subtask according to described the value of global attribute, judge; If global is true, then represent that this state is overall shared state, then by described give status processing module (2), and the task of waiting status processing module (2) completes message STA _2-1; Otherwise, if global is not true, then represent that this state is for local shared state, then flow described in the generation in processing module (1) thread directly perform;

The task load that computational threads is carried out by the mode of task stealing in stream processing module (1) the 6th aspect is balanced.

Stream processing module (1) the 7th aspect exports controller-to-switch message to Openflow Message Distribution Module (3).The controller-to-switch message synchronization needing to export is written to message-thread TH by computational threads ₃={ C ₁, C ₂..., C _cin belonging to link transmission buffer zone in.

Status processing module (2) first aspect receives the state processing tasks that Openflow message module (3) sends ${\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}}}\},$ And will ${\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}}}\}$ Be saved in status object STATE _{base_state}={ S ₁, S ₂..., S _saccess task queue in;

Status processing module (2) second aspect receives the state processing tasks that stream processing module (1) sends and will be saved in status object STATE _{base_state}={ S ₁, S ₂..., S _saccess task queue in;

Status processing module (2) third aspect state-thread TH ₂={ B ₁, B ₂..., B _bin B ₁from in extract and belong to B ₁access task queue $P_{\mathrm{state}}^{B_1}=\{P_1,P_2,...,P_s\};$ Then B ₁performed by the mode of poll $P_{\mathrm{state}}^{B_1}=\{P_1,P_2,...,P_s\}$ In task; When complete after, sending to stream processing module 1 of task completes message

State-thread TH ₂={ B ₁, B ₂..., B _bin B ₂from in extract and belong to B ₂access task queue then B ₂performed by the mode of poll in task; When complete after, sending to stream processing module (1) of task completes message

State-thread TH ₂={ B ₁, B ₂..., B _bin B _bfrom in extract and belong to B _baccess task queue then B _bperformed by the mode of poll in task; When complete after, sending to stream processing module 1 of task completes message

To the task that stream processing module (1) sends, massage set is completed for status processing module (2) fourth aspect be designated as ${\mathrm{STA}}_{2-1}=\{{\mathrm{STA}}_{2-1}^{B_1},{\mathrm{STA}}_{2-1}^{B_2},...,{\mathrm{STA}}_{2-1}^{B_b}\}.$

The advantage that the present invention is directed to the event concurrency disposal route of Openflow controller is:

1. the present invention is inner at Openflow controller, event handling and information receiving and transmitting are separated from each other, by using computational threads, parallel processing is carried out to Openflow event, parallel support is increased in stream event handler procedure inside, effectively can strengthen the computing power of Openflow controller, improve the extensibility of controller handling property.

2. using state-thread of the present invention processes uniquely to shared state, and non-exclusive mode can be used to conduct interviews to shared data, simplifies the access to shared data in event handler procedure, improves access efficiency to a certain extent.

Accompanying drawing explanation

Fig. 1 is the structured flowchart of the event concurrency controller that the present invention is based on Openflow.

Fig. 2 is the parallel process schematic diagram of Openflow controller inside of the present invention.

Fig. 3 is the speed-up ratio comparison diagram based on switch program.

Fig. 4 is the speed-up ratio comparison diagram based on QPAS algorithm.

Embodiment

Below in conjunction with accompanying drawing, the present invention is described in further detail.

Shown in Figure 1, a kind of event concurrency controller based on Openflow of the present invention, this controller includes stream processing module 1, status processing module 2 and Openflow message and distributes control module 3; Conveniently hereafter state, controller of the present invention is referred to as POCA.POCA of the present invention and existing Openflow controller with the use of, and to be embedded in Openflow network architecture.

In the present invention, POCA translates the Packet-in(in Openflow message: flow to and reach message), Flow-Removed(translates: drift except message), Port-status(translates: port status message) translate with Error(: error message) process that associates.

In the present invention, Packet-in(translates: flow to and reach message) corresponding event is called Packet-in event; Flow-Removed(translates: drift except message) corresponding event is called Flow-Removed event; Port-status(translates: port status message) corresponding event is called Port-status event; Error(translates: error message) corresponding event is called Error event.

In the present invention, the flow object FLOW of Base_flow structure _{base_flow}={ F ₁, F ₂..., F _fmiddle F ₁represent the flow object of the first type, F ₂represent the flow object of the second type, F _frepresent the flow object of last type, f is the identification number of flow object, for convenience of description, hereafter by F _falso referred to as the flow object of any one type.

In the present invention, the status object STATE of Base_state structure _{base_state}={ S ₁, S ₂..., S _smiddle S ₁represent the status object of the first type, S ₂represent the status object of the second type, S _srepresent the status object of last type, s represents the identification number of status object, for convenience of description, hereafter by S _salso referred to as the status object of any one type.Any status object by unique access task queue should be had, then the status object S of the first type ₁corresponding access task queue is designated as P ₁(referred to as first access task queue P ₁), the status object S of the second type ₂corresponding access task queue is designated as P ₂(referred to as second access task queue P ₂), the status object S of last type _scorresponding access task queue is designated as P _s(referred to as last access task queue P _s).Access task queue employing set expression-form is

In the present invention, the thread flowed in processing module 1 is designated as stream-thread TH ₁={ A ₁, A ₂..., A _z..., A _amiddle A ₁represent first thread in stream processing module 1, A ₂represent second thread in stream processing module 1, A _zrepresent z thread in stream processing module 1, A _arepresent last thread in stream processing module 1, a represents the thread ID in stream processing module 1, for convenience of description, hereafter by A _aalso referred to as any one thread.As stream-thread TH ₁={ A ₁, A ₂..., A _z..., A _ain some thread A _zafter main thread, then all the other threads are computational threads TH ₁={ A ₁, A ₂..., A _a.Any thread by unique local task queue should be had, then first thread A ₁corresponding local task queue is designated as Q ₁(referred to as first local task queue Q ₁), second thread A ₂corresponding local task queue is designated as Q ₂(referred to as second local task queue Q ₂), z thread A _zcorresponding local task queue is designated as Q _z(referred to as z local task queue Q _z, also referred to as the local task queue Q of main thread _z), last thread A _acorresponding local task queue is designated as Q _a(referred to as last local task queue Q _a).Computational threads TH ₁={ A ₁, A ₂..., A _acorresponding to local task queue set be designated as $Q^{T{H}_1}=\{Q_1,Q_2,...,Q_a\}.$

In the present invention, the thread in status processing module 2 is designated as state-thread TH ₂={ B ₁, B ₂..., B _bmiddle B ₁represent first thread in status processing module 2, B ₂represent second thread in status processing module 2, B _brepresent last thread in status processing module 2, b represents the thread ID in status processing module 2, for convenience of description, hereafter by B _balso referred to as any one thread.For the status object STATE in status processing module 2 _{base_state}={ S ₁, S ₂..., S _sthat mean allocation is at state-thread TH ₂={ B ₁, B ₂..., B _bon, then any one state-thread B _bon will process multiple access task queue, by described state-thread B _bthe access task queue of process is designated as $P_{\mathrm{state}}^{B_b}=\{P_1,P_2,...,P_s\},$ And $P_{\mathrm{state}}^{B_b}\∈P_{\mathrm{state}}^{\mathrm{STAT}{E}_{\mathrm{Base}\_\mathrm{state}}};$ Any access task queue P _swill to there being a unique thread B _b.

In the present invention, the thread that Openflow message is distributed in control module 3 is designated as message-thread TH ₃={ C ₁, C ₂..., C _cmiddle C ₁represent that Openflow message distributes first thread in control module 3, C ₂represent that Openflow message distributes second thread in control module 3, C _crepresent that Openflow message distributes last thread in control module 3, c represents that Openflow message distributes the thread ID in control module 3, for convenience of description, hereafter by C _calso referred to as any one thread.

Openflow message is distributed control module 3 and is designated as with multiple linking of Openflow switch 4 sV represents Openflow controller, and SW represents the set of Openflow switch, SW={D ₁, D ₂..., D _dmiddle D ₁represent first Openflow switch, D ₂represent second Openflow switch, D _drepresent last Openflow switch, d represents the identification number of Openflow switch, for convenience of description, hereafter by D _dalso referred to as any one Openflow switch.Article 1, link is designated as article 2 link is designated as the last item link is designated as (also referred to as bar link one by one arbitrarily ), ${\mathrm{CON}}_{\mathrm{SW}}^{\mathrm{SV}}=\{{\mathrm{CON}}_{D_1}^{\mathrm{SV}},{\mathrm{CON}}_{D_2}^{\mathrm{SV}},...,{\mathrm{CON}}_{D_d}^{\mathrm{SV}}\}.$ Linking between control module 3 with Openflow switch 4 is distributed for Openflow message that mean allocation is at message-thread TH ₃={ C ₁, C ₂..., C _con, and bar link one by one arbitrarily will to there being a unique thread C _c.

(1) Openflow message distributes control module 3

Shown in Figure 1, Openflow message is distributed control module 3 first aspect and is adopted asynchronous and unblock IO model from the reception buffer zone of link, receive the Openflow message of Openflow switch 4 transmission;

Packet-in message, Flow-Removed message, Port-status message and Error message is included in described Openflow message.

Openflow message distributes control module 3 second aspect will flow Processing tasks ${\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}}}\}$ Be sent to the local task queue Q of main thread of stream processing module 1 _zin;

In the present invention, described stream Processing tasks ${\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}}}\}$ Acquisition be: (A) is first according to Packet-in message trigger Packet-in event; Then the flow object FLOW as Base_flow structure in table 1 is generated according to Packet-in event _{base_flow}={ F ₁, F ₂..., F _f; Finally generate stream Processing tasks corresponding to described Packet-in event according to start method in Base_flow structure (B) first according to Flow-Removed message trigger Flow-Removed event; Then the flow object FLOW as Base_flow structure in table 1 is generated according to Flow-Removed event _{base_flow}={ F ₁, F ₂..., F _f; Finally generate stream Processing tasks corresponding to described Flow-Removed event according to start method in Base_flow structure

In the present invention, the flow object FLOW of Base_flow structure _{base_flow}={ F ₁, F ₂..., F _fmiddle F ₁represent the flow object of the first type, F ₂represent the flow object of the second type, F _frepresent the flow object of last type, f is the identification number of flow object, for convenience of description, hereafter by F _falso referred to as the flow object of any one type.

Table 1Base_flow class

Openflow message distributes control module 3 third aspect by state processing tasks ${\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}}}\}$ Be sent to the access task queue of status processing module 2 $P_{\mathrm{state}}^{\mathrm{STAT}{E}_{\mathrm{Base}\_\mathrm{state}}}=\{P_1,P_2,...,P_s\}$ In;

In the present invention, described state processing tasks ${\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}}}\}$ Acquisition be: (A) is first according to Port-status message trigger Port-status event; Then the status object STATE for Base_state structure in such as table 2 is generated according to Port-status event _{base_state}={ S ₁, S ₂..., S _sprocessing tasks, namely Port-status state processing tasks is designated as (B) first according to Error message trigger Error event; Then the status object STATE for Base_state structure in such as table 2 is generated according to Error event _{base_state}={ S ₁, S ₂..., S _sprocessing tasks, namely Error state processing tasks is designated as

Table 2Base_state class

Openflow message distributes the controller-to-switch message that control module 3 fourth aspect receives the output of stream processing module 1;

Openflow message is distributed control module 3 the 5th aspect and is adopted asynchronous and unblock IO model from message-thread TH ₃={ C ₁, C ₂..., C _cin belonging to link transmission buffer zone in export controller-to-switch message to Openflow switch 4.

(2) processing module 1 is flowed

Shown in Figure 1, stream processing module 1 first aspect distributes the stream Processing tasks of control module 3 output for receiving Openflow message ${\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}}}\};$

Second aspect will ${\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}}}\}$ Be saved in the local task queue Q of main thread _zin;

The third aspect will ${\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}}}\}$ The local task queue of computational threads of stream processing module 1 is sent to by the mode of poll in;

Fourth aspect performs ${\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}}}\}$ In specific tasks; And dynamically generate flow object FLOW _{base_flow}={ F ₁, F ₂..., F _fprocessing tasks, be designated as flow object subtask described in inciting somebody to action add to $Q^{T{H}_1}=\{Q_1,Q_2,...,Q_a\}$ In;

5th aspect performs ${\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}}}\}$ In specific tasks; And dynamically generate status object STATE _{base_state}={ S ₁, S ₂..., S _sprocessing tasks, be designated as status object subtask according to described the value of global attribute (as shown in table 2 the 4th row), judge; If global is true, then represent that this state is overall shared state, then by described give status processing module 2, and the task of waiting status processing module 2 completes message STA _2-1; Otherwise, if global is not true, then represent that this state is for local shared state, then flow described in the generation in processing module 1 thread directly perform;

Computational threads in 6th aspect stream processing module 1, by the mode of task stealing, carries out load balancing.

The relevant public information of described " task stealing mode ":

Article name: Schedulingmultithreadedcomputationsbyworkstealing

Author: RobertD.BlumofeUniv.ofTexasatAustin, Austin;

CharlesE.LeisersonMITLabforComputerScience,Cambridge,MA；

Deliver information: JournaloftheACM (JACM) JACMHomepagearchive

Volume46Issue5,Sept.1999，Pages720-748，ACMNewYork,NY,USA。

In the present invention, when stream processing module 1 receive status processing module 2 export task complete message afterwards, first judge whether that there is computational threads waits for this message, if existed, then order waits for the arrival of news ${\mathrm{STA}}_{2-1}=\{{\mathrm{STA}}_{2-1}^{B_1},{\mathrm{STA}}_{2-1}^{B_2},...,{\mathrm{STA}}_{2-1}^{B_b}\}$ Computational threads continue perform; Otherwise, ignore this message.

Stream processing module 1 the 7th aspect exports controller-to-switch message to Openflow Message Distribution Module 3.In the present invention, the controller-to-switch message synchronization needing to export is written to message-thread TH by computational threads ₃={ C ₁, C ₂..., C _cin belonging to link transmission buffer zone in.

(3) status processing module 2

Shown in Figure 1, status processing module 2 first aspect receives the state processing tasks that Openflow message module 3 sends ${\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}}}\},$ And will ${\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}}}\}$ Be saved in status object STATE _{base_state}={ S ₁, S ₂..., S _saccess task queue in;

Status processing module 2 second aspect receives the state processing tasks that stream processing module 1 sends and will be saved in status object STATE _{base_state}={ S ₁, S ₂..., S _saccess task queue in;

Status processing module 2 third aspect state-thread TH ₂={ B ₁, B ₂..., B _bin B ₁from in extract and belong to B ₁access task queue $P_{\mathrm{state}}^{B_1}=\{P_1,P_2,...,P_s\};$ Then B ₁performed by the mode of poll $P_{\mathrm{state}}^{B_1}=\{P_1,P_2,...,P_s\}$ In task; When complete after, sending to stream processing module 1 of task completes message

State-thread TH ₂={ B ₁, B ₂..., B _bin B ₂from in extract and belong to B ₂access task queue then B ₂performed by the mode of poll in task; When complete after, sending to stream processing module 1 of task completes message

State-thread TH ₂={ B ₁, B ₂..., B _bin B _bfrom in extract and belong to B _baccess task queue then B _bperformed by the mode of poll in task; When complete after, sending to stream processing module 1 of task completes message

To the task that stream processing module 1 sends, massage set is completed for status processing module 2 fourth aspect be designated as ${\mathrm{STA}}_{2-1}=\{{\mathrm{STA}}_{2-1}^{B_1},{\mathrm{STA}}_{2-1}^{B_2},...,{\mathrm{STA}}_{2-1}^{B_b}\}.$

Shown in Figure 2, adopt the event concurrency controller based on Openflow of the present invention's design to carry out the parallel processing of Openflow event, it comprises following parallel processing step:

Step one: the parallel transmitting-receiving of Openflow message, triggers corresponding Openflow event

In the link based on switch existence anduniquess each in the event concurrency controller of Openflow of the present invention.

Carry out in link process of establishing, message-thread TH ₃={ C ₁, C ₂..., C _cin first thread C ₁be responsible for Openflow switch SW={D ₁, D ₂..., D _dlinking request monitor.After receiving linking request, establish the link ${\mathrm{CON}}_{\mathrm{SW}}^{\mathrm{SV}}=\{{\mathrm{CON}}_{D_1}^{\mathrm{SV}},{\mathrm{CON}}_{D_2}^{\mathrm{SV}},...,{\mathrm{CON}}_{D_d}^{\mathrm{SV}}\},$ And will link ${\mathrm{CON}}_{\mathrm{SW}}^{\mathrm{SV}}$ Distribute to message-thread TH fifty-fifty ₃.Bar link one by one arbitrarily by a unique thread C _cprocess.

In Openflow message sink process, message-thread TH ₃={ C ₁, C ₂..., C _casynchronous and unblock IO model is adopted to receive Openflow switch SW={D from the reception buffer zone of link ₁, D ₂..., D _dthe Openflow message that sends.According to Packet-in message trigger Packet-in event; According to Flow-Removed message trigger Flow-Removed event; According to Port-status message trigger Port-status event; According to Error message trigger Error event.

In Openflow message transmitting process, message-thread TH ₃={ C ₁, C ₂..., C _cadopt asynchronous and unblock IO model from message-thread TH ₃={ C ₁, C ₂..., C _cin belonging to link transmission buffer zone in Openflow switch SW={D ₁, D ₂..., D _dexport controller-to-switch message.To link the action need of transmission buffer zone carry out synchronously.

In the present invention, the parallel transmitting-receiving of Openflow message is received and dispatched Openflow message with make use of multiple message-thread parallel, and each Openflow switch link is processed by unique message-thread, there is not mutual exclusion between message-thread.Therefore, Openflow information receiving and transmitting efficiency can be improved to greatest extent.In addition, utilize asynchronous and unblock IO model can reduce the interference of messaging procedure and message processing procedure, thus further increase information receiving and transmitting efficiency.

Step 2: the parallel processing of Openflow event

For Packet-in event and Flow-Removed event, first generate the flow object FLOW as Base_flow structure in table 1 _{base_flow}={ F ₁, F ₂..., F _f, then generate stream Processing tasks according to start method in Base_flow structure ${\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}}}\},$ Finally by this task ${\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}}}\}$ Be sent to the local task queue Q of main thread in stream processing module 1 _zin;

For stream Processing tasks ${\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}}}\}$ In stream processing module 1, main thread A _zwill ${\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}}}\}$ The local task queue of computational threads of stream processing module 1 is sent to by the mode of poll in; Computational threads TH ₁={ A ₁, A ₂..., A _aperform ${\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}}}\}$ In specific tasks; And dynamically generate flow object subtask described in inciting somebody to action add to $Q^{T{H}_1}=\{Q_1,Q_2,...,Q_a\}$ In;

Computational threads TH ₁={ A ₁, A ₂..., A _aperform ${\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}}}\}$ In specific tasks; And dynamically generate status object subtask according to described the value of global attribute (as shown in table 2 the 4th row), judge; If global is true, then represent that this state is overall shared state, then by described give status processing module 2, and the task of waiting status processing module 2 completes message STA _2-1; Otherwise, if global is not true, then represent that this state is for local shared state, then flow described in the generation in processing module 1 thread directly perform; Computational threads in stream processing module 1, by the mode of task stealing, carries out load balancing.

For Port-status event and Error event, first generate the status object STATE for Base_state structure in such as table 2 _{base_state}={ S ₁, S ₂..., S _sprocessing tasks ${\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}}}\},$ Then by this task ${\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}}}\}$ Be sent to the access task queue of status processing module 2 $P_{\mathrm{state}}^{{\mathrm{STATE}}_{\mathrm{Base}\_\mathrm{state}}}=\{P_1{,P}_2,...,P_s\}$ In.

For task ${\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}}}\}$ And task ${\mathrm{TASK}}_{{\mathrm{STATE}}_{\mathrm{Base}\_\mathrm{state}}}^{\mathrm{sub}},$ In status processing module 2, state-thread TH ₂={ B ₁, B ₂..., B _bin B ₁from in extract and belong to B ₁access task queue $P_{\mathrm{state}}^{B_1}=\{P_1,P_2,...,P_s\};$ Then B ₁performed by the mode of poll $P_{\mathrm{state}}^{B_1}=\{P_1,P_2,...,P_s\};$ In task; When complete after, sending to stream processing module 1 of task completes message state-thread TH ₂={ B ₁, B ₂..., B _bin B ₂from in extract and belong to B ₂access task queue then B ₂performed by the mode of poll in task; When complete after, sending to stream processing module 1 of task completes message state-thread TH ₂={ B ₁, B ₂..., B _bin B _bfrom in extract and belong to B _baccess task queue $P_{\mathrm{state}}^{B_b}=\{P_1,P_2,...,P_s\};$ Then B _bperformed by the mode of poll $P_{\mathrm{state}}^{B_b}=\{P_1,P_2,...,P_s\}$ In task; When complete after, sending to stream processing module 1 of task completes message

In the present invention, after receiving Openflow message, trigger corresponding Openflow event, and produce the Processing tasks to flow object and status object according to the type of event, transfer to different threads to carry out parallel processing.In stream event handler procedure, dynamically can produce subtask, utilize the mode of task stealing to be processed concurrently by multiple computational threads, improve stream event handling efficiency.In controller, each shared state is processed by unique state thread, not only simplify the access to shared state, and can improve the treatment effeciency of computational threads convection current event to a certain extent.Utilize the event concurrency disposal route in the present invention that Openflow controller can be made to have better performance extensibility.

checking embodiment

Based on the event concurrency disposal system POCA of Openflow message, when the switch program that execution calculated amount is little, compare other Openflow controllers, along with increasing of number of threads, when number of threads is greater than 8, POCA has higher speed-up ratio.Reason be each IO thread process separately belonging to switch link, there is not interference each other, therefore improve handling property.Speed-up ratio comparison diagram based on switch program shown in Figure 3.

Speed-up ratio comparison diagram based on QPAS algorithm shown in Figure 4.When the QPAS algorithm that computational processing is larger, along with increasing of number of threads, compared with NOX, POCA has higher speed-up ratio.Reason is: POCA carries out parallel accelerate in event handler procedure inside by computational threads, improves the treatment effeciency of each event, and then improves overall treatment effeciency.

The invention discloses a kind of event concurrency controller based on Openflow and event concurrency disposal route thereof, the process of the transmitting-receiving of Openflow message and Openflow event is separated by the method, utilizes extra computational threads to accelerate Openflow event handling.Application open after controller will set up and the linking of switch, and link is given fifty-fifty multiple I/O thread, each transmitting-receiving chaining message is by unique I/O thread process.Be applied in after receiving Openflow message, trigger corresponding Openflow event, and produce the Processing tasks to flow object and status object according to the type of event, transfer to different threads to process.In stream event handler procedure, dynamically can produce subtask, and be performed by multiple thread parallel.To shared state, unique state thread is used to process.The inventive method has better performance extensibility and simpler data access mode relative to the method for parallel processing of existing Openflow event.

Claims (4)

1. based on an event concurrency controller of Openflow, it is characterized in that: this controller includes stream processing module (1), status processing module (2) and Openflow message and distributes control module (3);

Openflow message distribution control module (3) first aspect employing asynchronous and unblock IO model receives the Openflow message that Openflow switch (4) sends from the reception buffer zone of link; Packet-in message, Flow-Removed message, Port-status message and Error message is included in described Openflow message;

Packet-in message refers to flow to and reaches message;

Flow-Removed message refers to drifts except message;

Port-status message refers to port status message;

Error message refers to error message;

Openflow message distributes control module (3) second aspect will flow Processing tasks ${\mathrm{TASK}}_{3-1}=\{{\mathrm{FA}}_{Packet-in}^{{\mathrm{FLOW}}_{Base-flow}},{\mathrm{FA}}_{Flow-\mathrm{Re}moved}^{{\mathrm{FLOW}}_{Base\_flow}}\}$ Be sent to the local task queue Q of main thread of stream processing module (1) _zin; represent the stream Processing tasks that Packet-in event is corresponding; represent the stream Processing tasks that Flow-Removed event is corresponding;

Described stream Processing tasks ${\mathrm{TASK}}_{3-1}=\{{\mathrm{FA}}_{Packet-in}^{{\mathrm{FLOW}}_{Base\_flow}},{\mathrm{FA}}_{Flow-\mathrm{Re}moved}^{{\mathrm{FLOW}}_{Base\_flow}}\}$ Acquisition be: (A) is first according to Packet-in message trigger Packet-in event; Then the flow object FLOW of Base_flow structure is generated according to Packet-in event _{base_flow}={ F ₁, F ₂..., F _f; Finally generate stream Processing tasks corresponding to described Packet-in event according to start method in Base_flow structure (B) first according to Flow-Removed message trigger Flow-Removed event; Then the flow object FLOW as Base_flow structure in table 1 is generated according to Flow-Removed event _{base_flow}={ F ₁, F ₂..., F _f; Finally generate stream Processing tasks corresponding to described Flow-Removed event according to start method in Base_flow structure

The flow object FLOW of Base_flow structure _{base_flow}={ F ₁, F ₂..., F _fmiddle F ₁represent the flow object of the first type, F ₂represent the flow object of the second type, F _frepresent the flow object of last type, f is the identification number of flow object;

Table 1Base_flow class

Openflow message distributes control module (3) third aspect by state processing tasks ${\mathrm{TASK}}_{3-2}=\{{\mathrm{SA}}_{Port-status}^{{\mathrm{STATE}}_{Base\_state}},{\mathrm{SA}}_{Error}^{{\mathrm{STATE}}_{Base\_state}}\}$ Be sent to the access task queue of status processing module (2) $P_{state}^{{\mathrm{STATE}}_{Base\_state}}=\{P_1,P_2,...,P_s\}$ In; represent Port-status state processing tasks; represent Error state processing tasks;

Described state processing tasks ${\mathrm{TASK}}_{3-2}=\{{\mathrm{SA}}_{Port-statu\stackrel{\‾}{s}}^{{\mathrm{STATE}}_{Base\_state}},{\mathrm{SA}}_{Error}^{{\mathrm{STATE}}_{Base\_state}}\}$ Acquisition be: (A) is first according to Port-status message trigger Port-status event; Then the status object STATE of Base_state structure is generated according to Port-status event _{base_state}={ S ₁, S ₂..., S _sprocessing tasks, namely Port-status state processing tasks is designated as (B) first according to Error message trigger Error event; Then the status object STATE for Base_state structure in such as table 2 is generated according to Error event _{base_state}={ S ₁, S ₂..., S _sprocessing tasks, namely Error state processing tasks is designated as

The status object STATE of Base_state structure _{base_state}={ S ₁, S ₂..., S _smiddle S ₁represent the status object of the first type, S ₂represent the status object of the second type, S _srepresent the status object of last type, s represents the identification number of status object;

Table 2Base_state class

Openflow message is distributed control module (3) fourth aspect and is received the controller-to-switch message flowing processing module (1) and export;

Openflow message is distributed control module (3) the 5th aspect and is adopted asynchronous and unblock IO model from message-thread TH ₃={ C ₁, C ₂..., C _cin belonging to link transmission buffer zone in export controller-to-switch message to Openflow switch (4);

Message-thread TH ₃={ C ₁, C ₂..., C _cmiddle C ₁represent that Openflow message distributes first thread in control module (3), C ₂represent that Openflow message distributes second thread in control module (3), C _crepresent that Openflow message distributes last thread in control module (3), c represents that Openflow message distributes the thread ID in control module (3);

The stream Processing tasks that stream processing module (1) first aspect exports for receiving Openflow message distribution control module (3) ${\mathrm{TASK}}_{3-1}=\{{\mathrm{FA}}_{Packet-in}^{{\mathrm{FLOW}}_{Base\_flow}},{\mathrm{FA}}_{Flow-\mathrm{Re}moved}^{{\mathrm{FLOW}}_{Base\_flow}}\};$

Stream processing module (1) second aspect will ${\mathrm{TASK}}_{3-1}=\{{\mathrm{FA}}_{Packet-in}^{{\mathrm{FLOW}}_{Base\_flow}},{\mathrm{FA}}_{Flow-\mathrm{Re}moved}^{{\mathrm{FLOW}}_{Base\_flow}}\}$ Be saved in the local task queue Q of main thread _zin;

Stream processing module (1) third aspect will ${\mathrm{TASK}}_{3-1}=\{{\mathrm{FA}}_{Packet-in}^{{\mathrm{FLOW}}_{Base\_flow}},{\mathrm{FA}}_{Flow-\mathrm{Re}moved}^{{\mathrm{FLOW}}_{Base\_flow}}\}$ The local task queue of computational threads is sent to by the mode of poll in;

Computational threads TH ₁={ A ₁, A ₂..., A _acorresponding to local task queue set be designated as stream-thread TH ₁={ A ₁, A ₂..., A _z..., A _amiddle A ₁represent first thread in stream processing module (1), A ₂represent second thread in stream processing module (1), A _zrepresent z thread in stream processing module (1), A _arepresent last thread in stream processing module (1), a represents the thread ID in stream processing module (1); First thread A ₁corresponding local task queue is designated as Q ₁, second thread A ₂corresponding local task queue is designated as Q ₂, z thread A _zcorresponding local task queue is designated as Q _z, last thread A _acorresponding local task queue is designated as Q _a;

Stream processing module (1) fourth aspect performs ${\mathrm{TASK}}_{3-1}=\{{\mathrm{FA}}_{Packet-in}^{{\mathrm{FLOW}}_{Base\_flow}},{\mathrm{FA}}_{Flow-\mathrm{Re}moved}^{{\mathrm{FLOW}}_{Base\_flow}}\}$ In specific tasks; And dynamically generate flow object FLOW _{base_flow}={ F ₁, F ₂..., F _fprocessing tasks, be designated as flow object subtask described in inciting somebody to action add to $Q^{{\mathrm{TH}}_1}=\{Q_1,Q_2,...,Q_a\}$ In;

Stream processing module (1) the 5th aspect performs ${\mathrm{TASK}}_{3-1}=\{{\mathrm{FA}}_{Packet-in}^{{\mathrm{FLOW}}_{Base\_flow}},{\mathrm{FA}}_{Flow-\mathrm{Re}moved}^{{\mathrm{FLOW}}_{Base\_flow}}\}$ In specific tasks; And dynamically generate status object STATE _{base_state}={ S ₁, S ₂..., S _sprocessing tasks, be designated as status object subtask according to described the value of global attribute, judge; If global is true, then represent that this state is overall shared state, then by described give status processing module (2), and the task of waiting status processing module (2) completes message STA _2-1; Otherwise, if global is not true, then represent that this state is for local shared state, then flow described in the generation in processing module (1) thread directly perform;

The status object STATE of Base_state structure _{base_state}={ S ₁, S ₂..., S _smiddle S ₁represent the status object of the first type, S ₂represent the status object of the second type, S _srepresent the status object of last type, s represents the identification number of status object;

The task load that computational threads is carried out by the mode of task stealing in stream processing module (1) the 6th aspect is balanced;

Stream processing module (1) the 7th aspect exports controller-to-switch message to Openflow Message Distribution Module (3); The controller-to-switch message synchronization needing to export is written to message-thread TH by computational threads ₃={ C ₁, C ₂..., C _cin belonging to link transmission buffer zone in;

TH ₃={ C ₁, C ₂..., C _cmiddle C ₁represent that Openflow message distributes first thread in control module (3), C ₂represent that Openflow message distributes second thread in control module (3), C _crepresent that Openflow message distributes last thread in control module (3), c represents that Openflow message distributes the thread ID in control module (3);

Status processing module (2) first aspect receives the state processing tasks that Openflow message module (3) sends ${\mathrm{TASK}}_{3-2}=\{{\mathrm{SA}}_{Port-status}^{{\mathrm{STATE}}_{Base\_state}},{\mathrm{SA}}_{Error}^{{\mathrm{STATE}}_{Base\_state}}\},$ And will ${\mathrm{TASK}}_{3-2}=\{{\mathrm{SA}}_{Port-status}^{{\mathrm{STATE}}_{Base\_state}},{\mathrm{SA}}_{Error}^{{\mathrm{STATE}}_{Base\_state}}\}$ Be saved in status object STATE _{base_state}={ S ₁, S ₂..., S _saccess task queue in;

Access task queue in the status object S of the first type ₁corresponding access task queue is designated as P ₁, the status object S of the second type ₂corresponding access task queue is designated as P ₂, the status object S of last type _scorresponding access task queue is designated as P _s;

Status processing module (2) second aspect receives the state processing tasks that stream processing module (1) sends and will be saved in status object STATE _{base_state}={ S ₁, S ₂..., S _saccess task queue in;

Status processing module (2) third aspect state-thread TH ₂={ B ₁, B ₂..., B _bin B ₁from in extract and belong to B ₁access task queue $P_{state}^{B_1}=\{P_1,P_2,...,P_s\},$ And $P_{state}^{B_1}\∈P_{state}^{{\mathrm{STATE}}_{Base\_state}};$ Then B ₁performed by the mode of poll in task; When complete after, sending to stream processing module (1) of task completes message

State-thread TH ₂={ B ₁, B ₂..., B _bmiddle B ₁represent first thread in status processing module (2), B ₂represent second thread in status processing module (2), B _brepresent last thread in status processing module (2), b represents the thread ID in status processing module (2);

State-thread TH ₂={ B ₁, B ₂..., B _bin B ₂from in extract and belong to B ₂access task queue $P_{state}^{B_2}=\{P_1,P_2,...,P_s\},$ And $P_{state}^{B_2}\∈P_{state}^{{\mathrm{STATE}}_{Base\_state}};$ Then B ₂performed by the mode of poll in task; When complete after, sending to stream processing module (1) of task completes message

State-thread TH ₂={ B ₁, B ₂..., B _bin B _bfrom in extract and belong to B _baccess task queue $P_{state}^{B_b}=\{P_1,P_2,...,P_s\},$ And $P_{state}^{B_b}\∈P_{state}^{{\mathrm{STATE}}_{Base\_state}};$ Then B _bperformed by the mode of poll in task; When complete after, sending to stream processing module (1) of task completes message

To the task that stream processing module (1) sends, massage set is completed for status processing module (2) fourth aspect be designated as ${\mathrm{STA}}_{2-1}=\{{\mathrm{STA}}_{2-1}^{B_1},{\mathrm{STA}}_{2-1}^{B_2},...,{\mathrm{STA}}_{2-1}^{B_b}\}.$

2. the event concurrency controller based on Openflow according to claim 1, is characterized in that: this controller and existing Openflow controller with the use of, and to be embedded in Openflow network architecture.

3., according to event concurrency disposal route of carrying out based on the event concurrency controller of Openflow according to claim 1, it is characterized in that there is the following step:

Step one: the parallel transmitting-receiving of Openflow message, triggers corresponding Openflow event

Based on the link of switch existence anduniquess each in the event concurrency controller of Openflow;

Carry out in link process of establishing, message-thread TH ₃={ C ₁, C ₂..., C _cin first thread C ₁be responsible for Openflow switch SW={D ₁, D ₂..., D _dlinking request monitor; After receiving linking request, establish the link ${\mathrm{CON}}_{SW}^{SV}=\{{\mathrm{CON}}_{D_1}^{SV},{\mathrm{CON}}_{D_2}^{SV},...,{\mathrm{CON}}_{D_d}^{SV}\},$ And will link distribute to message-thread TH fifty-fifty ₃; Bar link one by one arbitrarily by a unique thread C _cprocess;

In Openflow message sink process, message-thread TH ₃={ C ₁, C ₂..., C _casynchronous and unblock IO model is adopted to receive Openflow switch SW={D from the reception buffer zone of link ₁, D ₂..., D _dthe Openflow message that sends; According to Packet-in message trigger Packet-in event; According to Flow-Removed message trigger Flow-Removed event; According to Port-status message trigger Port-status event; According to Error message trigger Error event;

In Openflow message transmitting process, message-thread TH ₃={ C ₁, C ₂..., C _cadopt asynchronous and unblock IO model from message-thread TH ₃={ C ₁, C ₂..., C _cin belonging to link transmission buffer zone in Openflow switch SW={D ₁, D ₂..., D _dexport controller-to-switch message; To link the action need of transmission buffer zone carry out synchronously;

Step 2: the parallel processing of Openflow event

For Packet-in event and Flow-Removed event, first generate the flow object FLOW as Base_flow structure in table 1 _{base_flow}={ F ₁, F ₂..., F _f, then generate stream Processing tasks according to start method in Base_flow structure ${\mathrm{TASK}}_{3-1}=\{{\mathrm{FA}}_{Packet-in}^{{\mathrm{FLOW}}_{Base\_flow}},{\mathrm{FA}}_{Flow-\mathrm{Re}moved}^{{\mathrm{FLOW}}_{Base\_flow}}\},$ Finally by this task ${\mathrm{TASK}}_{3-1}=\{{\mathrm{FA}}_{Packet-in}^{{\mathrm{FLOW}}_{Base\_flow}},{\mathrm{FA}}_{Flow-\mathrm{Re}moved}^{{\mathrm{FLOW}}_{Base\_flow}}\}$ Be sent to the local task queue Q of main thread in stream processing module (1) _zin;

For stream Processing tasks ${\mathrm{TASK}}_{3-1}=\{{\mathrm{FA}}_{Packet-in}^{{\mathrm{FLOW}}_{Base\_flow}},{\mathrm{FA}}_{Flow-\mathrm{Re}moved}^{{\mathrm{FLOW}}_{Base\_flow}}\},$ In stream processing module (1), main thread A _zwill ${\mathrm{TASK}}_{3-1}=\{{\mathrm{FA}}_{Packet-in}^{{\mathrm{FLOW}}_{Base\_flow}},{\mathrm{FA}}_{Flow-\mathrm{Re}moved}^{{\mathrm{FLOW}}_{Base\_flow}}\}$ The local task queue of computational threads of stream processing module (1) is sent to by the mode of poll in; Computational threads TH ₁={ A ₁, A ₂..., A _aperform ${\mathrm{TASK}}_{3-1}=\{{\mathrm{FA}}_{Packet-in}^{{\mathrm{FLOW}}_{Base\_flow}},{\mathrm{FA}}_{Flow-\mathrm{Re}moved}^{{\mathrm{FLOW}}_{Base\_flow}}\}$ In specific tasks; And dynamically generate flow object subtask described in inciting somebody to action add to $Q^{{\mathrm{TH}}_1}=\{Q_1,Q_2,...,Q_a\}$ In;

Computational threads TH ₁={ A ₁, A ₂..., A _aperform ${\mathrm{TASK}}_{3-1}=\{{\mathrm{FA}}_{Packet-in}^{{\mathrm{FLOW}}_{Base\_flow}},{\mathrm{FA}}_{Flow-\mathrm{Re}moved}^{{\mathrm{FLOW}}_{Base\_flow}}\}$ In specific tasks; And dynamically generate status object subtask according to described the value of global attribute, judge; If global is true, then represent that this state is overall shared state, then by described give status processing module (2), and the task of waiting status processing module (2) completes message STA _2-1; Otherwise, if global is not true, then represent that this state is for local shared state, then flow described in the generation in processing module (1) thread directly perform; Computational threads in stream processing module (1), by the mode of task stealing, carries out load balancing;

For Port-status event and Error event, first generate the status object STATE for Base_state structure in such as table 2 _{base_state}={ S ₁, S ₂..., S _sprocessing tasks ${\mathrm{TASK}}_{3-2}=\{{\mathrm{SA}}_{Port-status}^{{\mathrm{STATE}}_{Base\_state}},{\mathrm{SA}}_{Error}^{{\mathrm{STATE}}_{Base\_state}}\},$ Then by this task ${\mathrm{TASK}}_{3-2}=\{{\mathrm{SA}}_{Port-status}^{{\mathrm{STATE}}_{Base\_state}},{\mathrm{SA}}_{Error}^{{\mathrm{STATE}}_{Base\_state}}\}$ Be sent to the access task queue of status processing module (2) $P_{state}^{{\mathrm{STATE}}_{Base\_state}}=\{P_1,P_2,...,P_s\}$ In;

For task ${\mathrm{TASK}}_{3-2}=\{{\mathrm{SA}}_{Port-status}^{{\mathrm{STATE}}_{Base\_state}},{\mathrm{SA}}_{Error}^{{\mathrm{STATE}}_{Base\_state}}\}$ And task in status processing module (2), state-thread TH ₂={ B ₁, B ₂..., B _bin B ₁from in extract and belong to B ₁access task queue $P_{state}^{B_1}=\{P_1,P_2,...,P_s\};$ Then B ₁performed by the mode of poll $P_{state}^{B_1}=\{P_1,P_2,...,P_s\}$ In task; When complete after, sending to stream processing module (1) of task completes message state-thread TH ₂={ B ₁, B ₂..., B _bin B ₂from in extract and belong to B ₂access task queue then B ₂performed by the mode of poll in task; When complete after, sending to stream processing module (1) of task completes message state-thread TH ₂={ B ₁, B ₂..., B _bin B _bfrom in extract and belong to B _baccess task queue $P_{state}^{B_b}=\{P_1,P_2,...,P_s\};$ Then B _bperformed by the mode of poll $P_{state}^{B_b}=\{P_1,P_2,...,P_s\}$ In task; When complete after, sending to stream processing module (1) of task completes message

4. according to event concurrency disposal route of carrying out based on the event concurrency controller of Openflow according to claim 1, it is characterized in that: along with increasing of number of threads has higher speed-up ratio.