X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;ds=sidebyside;f=doc%2Fguides%2Fprog_guide%2Fpacket_framework.rst;h=3d4e3b66cc5c0f5b82906ec85164cb57658f9b4d;hb=34fd4373ce76efd0236e59397c495762c2ec9e64;hp=f0b485669fa67b17ae27b5b669107ac8162ef8a5;hpb=5630257fcc30397e7217139ec55da4f301f59fb7;p=dpdk.git diff --git a/doc/guides/prog_guide/packet_framework.rst b/doc/guides/prog_guide/packet_framework.rst index f0b485669f..3d4e3b66cc 100644 --- a/doc/guides/prog_guide/packet_framework.rst +++ b/doc/guides/prog_guide/packet_framework.rst @@ -98,6 +98,10 @@ Port Types | | | character device. | | | | | +---+------------------+---------------------------------------------------------------------------------------+ + | 9 | Sym_crypto | Output port used to extract DPDK Cryptodev operations from a fixed offset of the | + | | | packet and then enqueue to the Cryptodev PMD. Input port used to dequeue the | + | | | Cryptodev operations from the Cryptodev PMD and then retrieve the packets from them. | + +---+------------------+---------------------------------------------------------------------------------------+ Port Interface ~~~~~~~~~~~~~~ @@ -1078,6 +1082,11 @@ with each table entry having its own set of enabled user actions and its own cop | | | checksum. | | | | | +---+-----------------------------------+---------------------------------------------------------------------+ + | 7 | Sym Crypto | Generate Cryptodev session based on the user-specified algorithm | + | | | and key(s), and assemble the cryptodev operation based on the | + | | | predefined offsets. | + | | | | + +---+-----------------------------------+---------------------------------------------------------------------+ Multicore Scaling ----------------- @@ -1133,9 +1142,86 @@ Typical devices with acceleration capabilities are: * Inline accelerators: NICs, switches, FPGAs, etc; -* Look-aside accelerators: chipsets, FPGAs, etc. +* Look-aside accelerators: chipsets, FPGAs, Intel QuickAssist, etc. Usually, to support a specific functional block, specific implementation of Packet Framework tables and/or ports and/or actions has to be provided for each accelerator, with all the implementations sharing the same API: pure SW implementation (no acceleration), implementation using accelerator A, implementation using accelerator B, etc. The selection between these implementations could be done at build time or at run-time (recommended), based on which accelerators are present in the system, with no application changes required. + +The Software Switch (SWX) Pipeline +---------------------------------- + +The Software Switch (SWX) pipeline is designed to combine the DPDK performance with the flexibility of the P4-16 language [1]. It can be used either by itself +to code a complete software switch or data plane application, or in combination with the open-source P4 compiler P4C [2], acting as a P4C back-end that allows +the P4 programs to be translated to the DPDK SWX API and run on multi-core CPUs. + +The main features of the SWX pipeline are: + +* Nothing is hard-wired, everything is dynamically defined: The packet headers (i.e. the network protocols), the packet meta-data, the actions, the tables + and the pipeline itself are dynamically defined instead of selected from a predefined set. + +* Instructions: The actions and the life of the packet through the pipeline are defined with instructions that manipulate the pipeline objects mentioned + above. The pipeline is the main function of the packet program, with actions as subroutines triggered by the tables. + +* Call external plugins: Extern objects and functions can be defined to call functionality that cannot be efficiently implemented with the existing + pipeline-oriented instruction set, such as: error detecting/correcting codes, cryptographic operations, meters, statistics counter arrays, heuristics, etc. + +* Better control plane interaction: Transaction-oriented table update mechanism that supports multi-table atomic updates. Multiple tables can be updated in a + single step with only the before-update and the after-update table entries visible to the packets. Alignment with the P4Runtime [3] protocol. + +* Performance: Multiple packets are in-flight within the pipeline at any moment. Each packet is owned by a different time-sharing thread in + run-to-completion, with the thread pausing before memory access operations such as packet I/O and table lookup to allow the memory prefetch to complete. + The instructions are verified and translated at initialization time with no run-time impact. The instructions are also optimized to detect and "fuse" + frequently used patterns into vector-like instructions transparently to the user. + +The main SWX pipeline components are: + +* Input and output ports: Each port instantiates a port type that defines the port operations, e.g. Ethernet device port, PCAP port, etc. The RX interface + of the input ports and the TX interface of the output ports are single packet based, with packet batching typically implemented internally by each port for + performance reasons. + +* Structure types: Each structure type is used to define the logical layout of a memory block, such as: packet headers, packet meta-data, action data stored + in a table entry, mailboxes of extern objects and functions. Similar to C language structs, each structure type is a well defined sequence of fields, with + each field having a unique name and a constant size. + +* Packet headers: Each packet typically has one or multiple headers. The headers are extracted from the input packet as part of the packet parsing operation, + which is likely executed immediately after the packet reception. As result of the extract operation, each header is logically removed from the packet, so + once the packet parsing operation is completed, the input packet is reduced to opaque payload. Just before transmission, one or several headers are pushed + in front of each output packet through the emit operation; these headers can be part of the set of headers that were previously extracted from the input + packet (and potentially modified afterwards) or some new headers whose contents is generated by the pipeline (e.g. by reading them from tables). The format + of each packet header is defined by instantiating a structure type. + +* Packet meta-data: The packet meta-data is filled in by the pipeline (e.g. by reading it from tables) or computed by the pipeline. It is not sent out unless + some of the meta-data fields are explicitly written into the headers emitted into the output packet. The format of the packet meta-data is defined by + instantiating a structure type. + +* Extern objects and functions: Used to plug into the pipeline any functionality that cannot be efficiently implemented with the existing pipeline instruction + set. Each extern object and extern function has its own mailbox, which is used to pass the input arguments to and retrieve the output arguments from the + extern object member functions or the extern function. The mailbox format is defined by instantiating a structure type. + +* Instructions: The pipeline and its actions are defined with instructions from a predefined instruction set. The instructions are used to receive and + transmit the current packet, extract and emit headers from/into the packet, read/write the packet headers, packet meta-data and mailboxes, start table + lookup operations, read the action arguments from the table entry, call extern object member functions or extern functions. See the rte_swx_pipeline.h file + for the complete list of instructions. + +* Actions: The pipeline actions are dynamically defined through instructions as opposed to predefined. Essentially, the actions are subroutines of the + pipeline program and their execution is triggered by the table lookup. The input arguments of each action are read from the table entry (in case of table + lookup hit) or the default table action (in case of table lookup miss) and are read-only; their format is defined by instantiating a structure type. The + actions have read-write access to the packet headers and meta-data. + +* Table: Each pipeline typically has one or more lookup tables. The match fields of each table are flexibly selected from the packet headers and meta-data + defined for the current pipeline. The set of table actions is flexibly selected for each table from the set of actions defined for the current pipeline. The + tables can be looked at as special pipeline operators that result in one of the table actions being called, depending on the result of the table lookup + operation. + +* Pipeline: The pipeline represents the main program that defines the life of the packet, with subroutines (actions) executed on table lookup. As packets + go through the pipeline, the packet headers and meta-data are transformed along the way. + +References: + +[1] P4-16 specification: https://p4.org/specs/ + +[2] P4-16 compiler: https://github.com/p4lang/p4c + +[3] P4Runtime specification: https://p4.org/specs/