On Sun, Jun 18, 2017 at 03:21:07PM +0800, Jiayu Hu wrote: > Generic Receive Offload (GRO) is a widely used SW-based offloading > technique to reduce per-packet processing overhead. It gains > performance by reassembling small packets into large ones. This > patchset is to support GRO in DPDK. To support GRO, this patch > implements a GRO API framework. > > To enable more flexibility to applications, DPDK GRO is implemented as > a user library. Applications explicitly use the GRO library to merge > small packets into large ones. DPDK GRO provides two reassembly modes. > One is called lightweigth mode, the other is called heavyweight mode. > If applications want merge packets in a simple way, they can use > lightweigth mode. If applications need more fine-grained controls, > they can choose heavyweigth mode. > > rte_gro_reassemble_burst is the main reassembly API which is used in > lightweigth mode and processes N packets at a time. For applications, > performing GRO in lightweigth mode is simple. They just need to invoke > rte_gro_reassemble_burst. Applications can get GROed packets as soon as > rte_gro_reassemble_burst returns. > > rte_gro_reassemble is the main reassembly API which is used in > lightweigth mode and processes one packet at a time. For applications,
Should be heavyweight here? > performing GRO in heavyweigth mode is relatively complicated. Before > performing GRO, applications need to create a GRO table by > rte_gro_tbl_create. Then they can use rte_gro_reassemble to process > packets one by one. The processed packets are in the GRO table. If > applications want to get them, applications need to manually flush > them by flush APIs. > Few typos: s/lightweigth/lightweight/g s/heavyweigth/heavyweight/g Besides, it's a bit confusing. Based on your comments in below mail: http://dpdk.org/ml/archives/dev/2017-June/068113.html The rte_gro_reassemble_burst() is used in heavyweight mode. But it is inconsistent with the description in above commit message. Best regards, Tiwei Bie
