CN111211931A

CN111211931A - Message forwarding system based on reconfigurable technology

Info

Publication number: CN111211931A
Application number: CN202010104995.1A
Authority: CN
Inventors: 田艳; 刘赫; 林汉忠
Original assignee: Shenzhen Forward Industrial Co Ltd
Current assignee: Shenzhen Forward Industrial Co Ltd
Priority date: 2020-02-20
Filing date: 2020-02-20
Publication date: 2020-05-29
Anticipated expiration: 2040-02-20
Also published as: CN111211931B

Abstract

The invention discloses a message forwarding system based on a reconfigurable technology, which comprises a multi-core network processor, a network message processing acceleration engine, a flow scheduling acceleration engine and a network interface module. According to the invention, the concurrent working thread of the multi-core network processor is reconstructed through the P4 compiling system, so that the protocol correlation of the forwarding system is decoupled; meanwhile, platform correlation of the forwarding system is decoupled through platform abstraction of the ODP; the decoupling design of the invention reduces the cost risk brought by newly added protocols and platform changes, and can fully utilize a special hardware acceleration engine and abundant network interface resources, so that the invention can be interconnected and networked with the traditional equipment, has uncommon forwarding performance, and meets certain industrial application conditions.

Description

Message forwarding system based on reconfigurable technology

Technical Field

The invention belongs to the technical field of network message forwarding, and particularly relates to a message forwarding system based on a reconfigurable technology.

Background

Cloud computing, Network Function Virtualization (NFV), Software Defined Networking (SDN) technologies are driving the evolution of new generation Network architectures. The technical ideas of network opening, virtualization, intelligence and fusion advocated by NFV and SDN are more and more widely accepted. The core idea of the NFV and SDN technical system is as follows: the software and hardware of the network element are decoupled, and the network control plane and the data plane are decoupled, so that the software function is abstracted and virtualized, and the network is programmable and reconfigurable.

The development of SDN technology can be divided into two phases: the SDN is based on an Openflow architecture technology, and the SDN is based on a P4(Programming Protocol-Independent Packet Processors) architecture technology. As a core technology of the second generation SDN, P4 provides a protocol-independent forwarding model, overcomes the problem of expansibility due to insufficient abstract capability of a data plane and no programming capability caused by the dependence of Openflow on a protocol, and has a wide application value for network update, network upgrade and fast iteration.

As a leading-edge technical means, the current domestic research on P4 is still basically in an experimental stage, and mainly depends on a virtual machine environment. Referring to fig. 1, a diagram of a prior reconfigurable forwarding system in China is shown. The system is built based on a virtual machine environment, the hardware basis is a host system (emphasizing performance general selection server equipment) consisting of a general CPU, an Ethernet physical network card and the like, and the verification platform mainly consists of virtual machine system software, a virtual network card and a P4 virtual switch. Due to the restriction of hardware conditions, the research method focuses on understanding the P4 programming idea, is familiar with the P4 language development process, cannot be communicated with the existing network equipment, and has no industrial application value.

Disclosure of Invention

In order to solve the above problems in the prior art, the present invention provides a packet forwarding system that uses a P4 network device of a reconfigurable technology to implement interconnection with a conventional network.

In order to achieve the purpose of the invention, the invention adopts the technical scheme that:

a message forwarding system based on reconfigurable technology comprises a multi-core network processor, a network message processing acceleration engine, a flow scheduling acceleration engine and a network interface module;

the multi-core network processor is used for carrying out multi-level message buffering, exchanging data messages with a network message processing acceleration engine in a DMA + PCIE mode, and carrying out deep processing on network data through a plurality of working threads;

the network message processing acceleration engine is used for receiving the message through the network interface module, judging whether to send the message to the flow management scheduling engine and forward the message from the network interface module according to the forwarding processing logic or send the message to the multi-core network processor through the PCIE channel for deep processing of the message;

and the flow scheduling acceleration engine is used for receiving the message from the network message processing acceleration engine and forwarding the message from the network interface module at the set moment according to the flow scheduling strategy judgment.

Furthermore, the working thread of the multi-core network processor adopts a P4 programming model, and the software composition of the multi-core network processor comprises a message IO interface unit, a message parser, a message matching unit, a policy processing unit and a message table item management module.

Further, the message IO interface unit is configured to receive and transmit a message from an interface provided by a network message accelerated processing engine; the message analyzer is used for classifying and analyzing the messages; the message matching unit extracts message fields from the message analyzer and outputs an execution strategy of the message according to the table look-up of the message characteristic fields; the strategy processing unit is used for processing the execution strategy generated by the message matching unit; the message table item management module is used for carrying out comprehensive management on table items, generating a software logic table and updating the hardware configuration of the software logic table through a table writing interface provided by a network message processing acceleration engine.

Further, the software architecture of the multi-core network processor comprises an ODP layer and a P4 layer, the ODP layer is defined with an API facing software forwarding development, and the P4 layer comprises a P4 front-end compiler and a P4 back-end compiler.

Further, the ODP layer defined API is decomposed into an application-oriented User API and an architecture-oriented RUNTIME API, which is referred to by the User API through function calls.

Further, the P4 front-end compiler is used to compile P4 source code into an intermediate representation layer, and the P4 back-end compiler is used for automatic mapping of P4 programs to the RUNTIME API.

Further, the P4 backend compiler includes PARSER _ P4 backend compilation, TABLE _ P4 backend compilation, ACTION _ P4 backend compilation, MATCH _ P4 backend compilation, and Control _ P4 backend compilation.

Further, the PARSER _ P4 back end compiles a source code for generating an adaptive ODP message parsing API according to a P4 high-level interface request, the TABLE _ P4 back end compiles a source code for generating an adaptive ODP TABLE look-up API according to a P4 high-level interface request, the ACTION _ P4 back end compiles a source code for generating policy processing according to a P4 high-level interface request, the MATCH _ P4 back end compiles a source code for generating a message matching according to a P4 high-level interface request, and the Control _ P4 back end compiles a source code for generating a TABLE entry forwarding according to a P4 high-level interface request.

The invention has the following beneficial effects: according to the invention, the concurrent working thread of the multi-core network processor is reconstructed through the P4 compiling system, so that the protocol correlation of the forwarding system is decoupled; meanwhile, platform correlation of the forwarding system is decoupled through platform abstraction of the ODP; the decoupling design of the invention reduces the cost risk brought by newly added protocols and platform changes, and can fully utilize a special hardware acceleration engine and abundant network interface resources, so that the invention can be interconnected and networked with the traditional equipment, has uncommon forwarding performance, and meets certain industrial application conditions.

Drawings

Fig. 1 is a schematic diagram of a conventional reconfigurable forwarding system architecture;

FIG. 2 is a schematic diagram of a message forwarding system based on reconfigurable technology according to the present invention;

FIG. 3 is a diagram illustrating software components of a multi-core network processor according to an embodiment of the invention;

FIG. 4 is a diagram illustrating a software architecture of a multi-core network processor according to an embodiment of the invention;

FIG. 5 is a schematic diagram of the P4 compiling system in the embodiment of the invention.

Detailed Description

In order to make the objects, technical solutions and advantages of the present invention more apparent, the present invention is described in further detail below with reference to the accompanying drawings and embodiments. It should be understood that the specific embodiments described herein are merely illustrative of the invention and are not intended to limit the invention.

As shown in fig. 2, an embodiment of the present invention provides a message forwarding system based on a reconfigurable technology, including a multi-core network processor, a network message processing acceleration engine, a traffic scheduling acceleration engine, and a network interface module. The invention follows the modeling method of the reconfigurable forwarding plane and realizes the programmable message forwarding system on the basis of the hardware of the self-developed network processor.

The multi-core network processor realizes multi-level message buffering based on RISC architecture, and adopts DMA (Direct memory access ) + PCIE (peripheral component interconnect express) mode to interact data message with the network message processing acceleration engine. Through zero copy technology, a plurality of working threads are concurrently performed on a network processor to perform deep processing of network data. These worker threads are developed based on high level languages, with native programmable properties.

In an optional embodiment of the present invention, a software architecture of a work thread of a multi-core network processor adopts a P4 programming model, a concurrent work thread of the multi-core network processor is a main body for implementing the P4 programming model, and a software component of the multi-core network processor is composed of two parts: protocol dependent sub-modules, protocol independent sub-modules. Dividing basis: the protocol related sub-modules are affected by the message characteristics (such as IPv4, IPv6, MPLS, etc.).

The design of the protocol related sub-modules completely follows the P4 programming model and can be reconstructed by the P4 compiling system, namely regenerated under the processing of the P4 compiling system according to the P4 source file.

The protocol independent sub-modules have close coupling with system resource management, for example, the logic processing of the working thread to receive and send the message through the message IO interface described above belongs to this part. The design of this section is referenced to the ODP model. Odp (open dataplane) model: the ODP comprises a group of APIs (application programming interfaces) for abstractly describing a data forwarding function model, and the API specification of the ODP covers data forwarding basic functions such as data receiving, message operation, message transmission and the like, but does not define the concrete implementation of the API specification, and is adapted to a concrete platform.

The software composition specifically comprises a message IO interface unit, a message analyzer, a message matching unit, a strategy processing unit, a message table item management module and the like.

Message IO interface unit (PKTIO): the working thread receives and transmits the message from an interface (NPE.ko) provided by the network message acceleration processing engine through the module. The module is protocol-independent and supports unicast, multicast and broadcast receiving and transmitting modes.

Message PARSER (PARSER): the module for realizing the classification analysis of the message is a module related to the protocol. Its forwarding abstract behavior can be defined by the P4 language and regenerated by the P4 compilation system.

Message matching UNIT (MATCH UNIT): and extracting message fields from the PARSER, and outputting an execution strategy of the message according to the table look-up of the message characteristic fields. The method comprises two parts of protocol correlation and protocol independence. Wherein the protocol-related part (MATCH _ P4) can be defined by the P4 language and reconstructed by the P4 compiling system. The protocol independent part (MATCH _ ODP) is logic formed by a group of ODP table look-up interfaces, and supports various table look-up algorithms such as longest MATCH (LPM), EXACT look-up (EXACT), HASH and the like.

Policy processing UNIT (ACTION UNIT): the execution strategy generated from the MATCH UNIT supports the processing of message field modification, data verification, data discarding, data redirection, data transmission and the like.

Message TABLE entry management module (TABLE MANAGER): the method is an interface logic of a control plane, realizes the comprehensive management of table items, generates a set of software logic table, and updates the hardware configuration of the table through a table writing interface provided by a network message processing acceleration engine. The module also comprises a protocol dependent (TABLE _ ODP) and a protocol independent submodule (TABLE _ P4), and the implementation method is similar to the previous units and is also implemented through ODP TABLE entry management interface and P4 compiling system reconstruction.

As shown in fig. 4, the software architecture of the multi-core network processor is a forwarding plane architecture combining ODP + P4, and includes an ODP layer and a P4 layer.

The ODP layer is defined with an API facing software forwarding development, the API defined by the ODP layer is decomposed into a UserAPI facing application and an RUNTIME API facing architecture, wherein the RUNTIME API can be regarded as a specific implementation of the adaptation architecture and is referred to by the UserAPI through function call. Further, the RUNTIME API may also use some functions of the ODP core library to complete the corresponding logic.

The P4 layer includes a P4 front-end compiler and a P4 back-end compiler. The front-end compiler compiles the P4 source code into an intermediate presentation layer, and the invention directly adopts a P4-HLIR front-end compiler provided by a P4 open source organization. The back-end compiler implements the automatic mapping of the P4 program to the RUNTIME API.

As shown in FIG. 5, the P4 back-end compiler includes PARSER _ P4 back-end compilation, TABLE _ P4 back-end compilation, ACTION _ P4 back-end compilation, MATCH _ P4 back-end compilation, and Control _ P4 back-end compilation.

PARSER _ P4 backend compilation: the output information of the P4-HLIR is compiled through the back end of PARSER _ P4, and then the parser.c and parser.h source codes which are realized by C language and are adapted to the ODP message parsing API are generated.

TABLE _ P4 backend compilation: the output information of the P4-HLIR is compiled through the back end of TABLE _ P4, and then the C language implemented table.c, table.h source code of the adaptive ODP TABLE look-up API is generated.

ACTION _ P4 back-end compilation: the P4-HLIR output information is compiled through the back end of the ACTION _ P4, and the action.c and action.h source codes realized by C language are generated.

MATCH _ P4 back-end compilation: the output information of the P4-HLIR is compiled and processed through the back end of MATCH _ P4, and data _ pipeline.c and data _ pipeline.h source codes realized by C language are generated.

Control _ P4 back-end compilation: the output information of the P4-HLIR is compiled at the back end of Control _ P4, and the control.c and control.h source codes realized by C language are generated.

As shown in fig. 3, the software architecture of the multi-core network processor is specifically subdivided into:

(1) ko of npe: and the NPE kernel driving module is adaptive to the NPE FPGA.

(2) Worker threads: i.e., the threads component of ODP, the implementation of each thread may be a thread or process of Linux. Each thread uses a CPU affinity attribute interface, bound to a physical CPU. For convenience of description, there are defined counters, which are command line parameters that the user can configure.

(3) Pool: the Pool component of ODP is a high abstraction of the shared memory management object.

(4) Timer: the Timer component of ODP is an abstraction of a Timer.

(5) PKTIO: the PktIO component of the ODP is a standard interface for adapting forwarding software to message transceiving interfaces of different platforms.

(6) The HAL component of the ODP essentially comprises:

tables: the entry management component of the ODP is a standard interface for forwarding software to adapt to different platforms for forwarding entry management.

A Classfier: the message classification component of the ODP is a standard interface for the forwarding software to adapt to different platforms for message analysis.

Packet: the message component of the ODP is a standard interface for adapting the forwarding software to different platforms to operate the message content.

(7) Packet _ descriptor: the message descriptor is also a bearing unit of message data information.

(8)Parser：

At the level of P4: the abstract description of the P4 on the message parsing corresponds to the parser object of the P4 syntax.

At the ODP level: ODP classfer component.

(9)Table：

At the level of P4: the abstract description of the forwarding table entry by P4 corresponds to the table object of the P4 syntax.

At the ODP level: ODP Table component (a set of entry management interfaces).

(10)Action：

At the level of P4: p4 is an abstract description of the table item search result, corresponding to the action object of P4 syntax.

At the ODP level: a set of policy enforcement interfaces of the ODP packet component, such as checksum computations, etc.

(11) Data _ pipeline: the Pipeline logical abstraction of the text forwarding process is implemented using the P4 syntax component.

(12) Control _ flow: the P4 grammar component is used to implement a logical abstraction of the forwarding entry self-learning process.

The following explains the implementation method of the P4 compiling system implemented by the invention as follows:

considering the P4-HLIR implementation, the P4 back-end compiler of the present invention is implemented based on the python language. According to the P4-HLIR programming guide, a P4-HLIR module is referenced by an import statement and a key interface HLIR () of the module is used for compiling a P4 source file, the compiling result of the P4-HLIR is used as a complete intermediate representation layer object, and then semantic conversion of different objects is realized by combining the interface definition of the P4-HLIR.

The P4 object is first a Python object, the underlying object type (P4 object type) has action, table, etc. Each object is instantiated as a dictionary object, above which dictionary names of these types can be referenced by other Python compilers.

The back-end compilation of control, dataplane, table, parser, action, etc. of the present invention is to further convert the P4 object into a C-file using the specific interface of the P4-HLIR programming guide.

The Control modules (control.c, control.h) are a block that is tightly bound to the table.

The main logic is as follows:

1. receiving an entry management message of a controller (which can be implemented based on Openflow or P4 RUNTIME);

2. and analyzing the message, and using a corresponding Table item management function, and further calling the ODP Table API and the NPE hardware Table writing interface.

3. The method comprises the steps of defining the realization of various table item management functions, mainly extracting keys and values of table item messages sent by a controller, and adding the keys and the values by using a relatively uniform table item management interface.

A Data _ pipeline module (Data _ pipeline.c, Data _ pipeline.h) implements logic for pipeline processing of a packet.

The main process is as follows:

1. receiving a message by using a receive _ packet (), calling a packet receiving interface function ODP _ pktin _ recv () of an ODP PKTIO (adaptive NPE hardware platform), and receiving a message from a network message forwarding acceleration engine through an interface provided by NPE.ko by the function;

2. entering message Pipeline processing described by a P4 state machine through a receive _ packet (), updating message content after a series of MATCH-ACTION processing, and outputting an exit ID of the message;

3. and calling ODP PKTIO again according to the exit ID indicated by the message descriptor to finish the forwarding or discarding of the message.

MATCH _ P4 back-end processing parses all the application logic of the P4 source file and maps each P4 application function to the corresponding C function of application _ table _ name. The function will judge to select the corresponding general table look-up API for the matching type of the current table, to perform table look-up operation, if it can match, then further perform action or recursive application processing according to the grammar logic defined by the application, that is, can call the next application _ table function or the action _ code function (action backend compiler mapping result) corresponding to the action.

Examples are: for IP forwarding processing, LPM (longest match) is generally used, and the corresponding general lookup API is LPM _ lookup, and the lookup API of ODP is further used in this API: odph _ iplaokup _ table _ get _ value ().

The key parameter key of the table lookup comes from pd, and different table entries have an API for extracting the key: table _ name _ key, which extracts a key from pd according to the table match field definition (the key data for pd is generated by parser).

Further, the ODP table lookup API and the message analysis API can be associated with hardware resources of a network message processing acceleration engine, so that the forwarding processing of the messages is accelerated, and the system performance is improved.

The same logic applies equally to the policy enforcement logic, such as IP forwarding recalculation of IP header checksums can use hardware computing resources. In some security application scenarios, hardware security processing logic, such as data encryption, can also be used.

The invention combines the P4 and ODP forwarding plane modeling method, and successfully decouples the protocol correlation and platform correlation of the forwarding system through the design of combining software and hardware. The self-developed P4 compiling system is used for reconstructing the concurrent working threads of the multi-core processor, and the protocol correlation of the forwarding system is decoupled. Platform dependencies of the forwarding system are decoupled through platform abstraction of the ODP. The decoupling design of the forwarding system reduces the cost risk caused by newly added protocols and platform changes. On the other hand, the reconfigurable message forwarding system realized by the invention can fully utilize a special hardware acceleration engine and abundant network interface resources, so that the equipment can be interconnected and networked with the traditional equipment, has uncommon forwarding performance, meets certain industrial application conditions, is not limited to laboratory application any more, and can better evaluate the application value brought by the programmable forwarding technology.

It will be appreciated by those of ordinary skill in the art that the embodiments described herein are intended to assist the reader in understanding the principles of the invention and are to be construed as being without limitation to such specifically recited embodiments and examples. Those skilled in the art can make various other specific changes and combinations based on the teachings of the present invention without departing from the spirit of the invention, and these changes and combinations are within the scope of the invention.

Claims

1. A message forwarding system based on reconfigurable technology is characterized by comprising a multi-core network processor, a network message processing acceleration engine, a flow scheduling acceleration engine and a network interface module;

2. A message forwarding system based on reconfigurable technology according to claim 1, wherein the working thread of the multi-core network processor adopts P4 programming model, and its software composition includes message IO interface unit, message parser, message matching unit, policy processing unit and message table item management module.

3. A message forwarding system based on reconfigurable technology as claimed in claim 2, wherein the message IO interface unit is configured to receive and transmit messages from an interface provided by a network message acceleration processing engine; the message analyzer is used for classifying and analyzing the messages; the message matching unit extracts message fields from the message analyzer and outputs an execution strategy of the message according to the table look-up of the message characteristic fields; the strategy processing unit is used for processing the execution strategy generated by the message matching unit; the message table item management module is used for carrying out comprehensive management on table items, generating a software logic table and updating the hardware configuration of the software logic table through a table writing interface provided by a network message processing acceleration engine.

4. The reconfigurable technology-based message forwarding system of claim 3, wherein the software architecture of the multi-core network processor comprises an ODP layer and a P4 layer, the ODP layer is defined with an API for software forwarding development, and the P4 layer comprises a P4 front-end compiler and a P4 back-end compiler.

5. A reconfigurable technology-based message forwarding system according to claim 4, wherein the ODP layer-defined APIs are decomposed into an application-oriented User API and an architecture-oriented RUNTIME API, which is referenced by the User API through function calls.

6. The reconfigurable technology-based message forwarding system of claim 5, wherein the P4 front-end compiler is configured to compile P4 source code into an intermediate representation layer, and the P4 back-end compiler is configured to automatically map P4 programs to RUNTIME API.

7. The reconfigurable technology-based message forwarding system of claim 6, wherein the P4 backend compiler comprises PARSER _ P4 backend compilation, TABLE _ P4 backend compilation, ACTION _ P4 backend compilation, MATCH _ P4 backend compilation, and Control _ P4 backend compilation.

8. The reconfigurable technology-based message forwarding system according to claim 7, wherein the PARSER _ P4 backend compiles source code for generating an adapted ODP message parsing API according to a P4 high-level interface request, the TABLE _ P4 backend compiles source code for generating an adapted ODP TABLE look-up API according to a P4 high-level interface request, the ACTION _ P4 backend compiles source code for generating policy processing according to a P4 high-level interface request, the MATCH _ P4 backend compiles source code for generating message matching according to a P4 high-level interface request, and the Control _ P4 backend compiles source code for generating TABLE entry forwarding according to a P4 high-level interface request.