From patchwork Fri Oct 1 14:02:51 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Ananyev, Konstantin" X-Patchwork-Id: 100295 X-Patchwork-Delegate: ferruh.yigit@amd.com Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id 58515A0032; Fri, 1 Oct 2021 16:08:34 +0200 (CEST) Received: from [217.70.189.124] (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 47D34411A2; Fri, 1 Oct 2021 16:08:34 +0200 (CEST) Received: from mga01.intel.com (mga01.intel.com [192.55.52.88]) by mails.dpdk.org (Postfix) with ESMTP id CC3BD4119D for ; Fri, 1 Oct 2021 16:08:32 +0200 (CEST) X-IronPort-AV: E=McAfee;i="6200,9189,10123"; a="248003608" X-IronPort-AV: E=Sophos;i="5.85,339,1624345200"; d="scan'208";a="248003608" Received: from fmsmga005.fm.intel.com ([10.253.24.32]) by fmsmga101.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 01 Oct 2021 07:04:33 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.85,339,1624345200"; d="scan'208";a="709883246" Received: from sivswdev08.ir.intel.com ([10.237.217.47]) by fmsmga005.fm.intel.com with ESMTP; 01 Oct 2021 07:04:25 -0700 From: Konstantin Ananyev To: dev@dpdk.org Cc: xiaoyun.li@intel.com, anoobj@marvell.com, jerinj@marvell.com, ndabilpuram@marvell.com, adwivedi@marvell.com, shepard.siegel@atomicrules.com, ed.czeck@atomicrules.com, john.miller@atomicrules.com, irusskikh@marvell.com, ajit.khaparde@broadcom.com, somnath.kotur@broadcom.com, rahul.lakkireddy@chelsio.com, hemant.agrawal@nxp.com, sachin.saxena@oss.nxp.com, haiyue.wang@intel.com, johndale@cisco.com, hyonkim@cisco.com, qi.z.zhang@intel.com, xiao.w.wang@intel.com, humin29@huawei.com, yisen.zhuang@huawei.com, oulijun@huawei.com, beilei.xing@intel.com, jingjing.wu@intel.com, qiming.yang@intel.com, matan@nvidia.com, viacheslavo@nvidia.com, sthemmin@microsoft.com, longli@microsoft.com, heinrich.kuhn@corigine.com, kirankumark@marvell.com, andrew.rybchenko@oktetlabs.ru, mczekaj@marvell.com, jiawenwu@trustnetic.com, jianwang@trustnetic.com, maxime.coquelin@redhat.com, chenbo.xia@intel.com, thomas@monjalon.net, ferruh.yigit@intel.com, mdr@ashroe.eu, jay.jayatheerthan@intel.com, Konstantin Ananyev Date: Fri, 1 Oct 2021 15:02:51 +0100 Message-Id: <20211001140255.5726-4-konstantin.ananyev@intel.com> X-Mailer: git-send-email 2.18.0 In-Reply-To: <20211001140255.5726-1-konstantin.ananyev@intel.com> References: <20210922140953.19388-1-konstantin.ananyev@intel.com> <20211001140255.5726-1-konstantin.ananyev@intel.com> Subject: [dpdk-dev] [PATCH v3 3/7] ethdev: copy ethdev 'fast' API into separate structure X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Sender: "dev" Copy public function pointers (rx_pkt_burst(), etc.) and related pointers to internal data from rte_eth_dev structure into a separate flat array. That array will remain in a public header. The intention here is to make rte_eth_dev and related structures internal. That should allow future possible changes to core eth_dev structures to be transparent to the user and help to avoid ABI/API breakages. The plan is to keep minimal part of data from rte_eth_dev public, so we still can use inline functions for 'fast' calls (like rte_eth_rx_burst(), etc.) to avoid/minimize slowdown. Signed-off-by: Konstantin Ananyev --- lib/ethdev/ethdev_private.c | 52 ++++++++++++++++++++++++++++++++++++ lib/ethdev/ethdev_private.h | 7 +++++ lib/ethdev/rte_ethdev.c | 17 ++++++++++++ lib/ethdev/rte_ethdev_core.h | 45 +++++++++++++++++++++++++++++++ 4 files changed, 121 insertions(+) diff --git a/lib/ethdev/ethdev_private.c b/lib/ethdev/ethdev_private.c index 012cf73ca2..3eeda6e9f9 100644 --- a/lib/ethdev/ethdev_private.c +++ b/lib/ethdev/ethdev_private.c @@ -174,3 +174,55 @@ rte_eth_devargs_parse_representor_ports(char *str, void *data) RTE_LOG(ERR, EAL, "wrong representor format: %s\n", str); return str == NULL ? -1 : 0; } + +static uint16_t +dummy_eth_rx_burst(__rte_unused void *rxq, + __rte_unused struct rte_mbuf **rx_pkts, + __rte_unused uint16_t nb_pkts) +{ + RTE_ETHDEV_LOG(ERR, "rx_pkt_burst for unconfigured port\n"); + rte_errno = ENOTSUP; + return 0; +} + +static uint16_t +dummy_eth_tx_burst(__rte_unused void *txq, + __rte_unused struct rte_mbuf **tx_pkts, + __rte_unused uint16_t nb_pkts) +{ + RTE_ETHDEV_LOG(ERR, "tx_pkt_burst for unconfigured port\n"); + rte_errno = ENOTSUP; + return 0; +} + +void +eth_dev_fp_ops_reset(struct rte_eth_fp_ops *fpo) +{ + static void *dummy_data[RTE_MAX_QUEUES_PER_PORT]; + static const struct rte_eth_fp_ops dummy_ops = { + .rx_pkt_burst = dummy_eth_rx_burst, + .tx_pkt_burst = dummy_eth_tx_burst, + .rxq = {.data = dummy_data, .clbk = dummy_data,}, + .txq = {.data = dummy_data, .clbk = dummy_data,}, + }; + + *fpo = dummy_ops; +} + +void +eth_dev_fp_ops_setup(struct rte_eth_fp_ops *fpo, + const struct rte_eth_dev *dev) +{ + fpo->rx_pkt_burst = dev->rx_pkt_burst; + fpo->tx_pkt_burst = dev->tx_pkt_burst; + fpo->tx_pkt_prepare = dev->tx_pkt_prepare; + fpo->rx_queue_count = dev->rx_queue_count; + fpo->rx_descriptor_status = dev->rx_descriptor_status; + fpo->tx_descriptor_status = dev->tx_descriptor_status; + + fpo->rxq.data = dev->data->rx_queues; + fpo->rxq.clbk = (void **)(uintptr_t)dev->post_rx_burst_cbs; + + fpo->txq.data = dev->data->tx_queues; + fpo->txq.clbk = (void **)(uintptr_t)dev->pre_tx_burst_cbs; +} diff --git a/lib/ethdev/ethdev_private.h b/lib/ethdev/ethdev_private.h index 3724429577..40333e7651 100644 --- a/lib/ethdev/ethdev_private.h +++ b/lib/ethdev/ethdev_private.h @@ -26,4 +26,11 @@ eth_find_device(const struct rte_eth_dev *_start, rte_eth_cmp_t cmp, /* Parse devargs value for representor parameter. */ int rte_eth_devargs_parse_representor_ports(char *str, void *data); +/* reset eth 'fast' API to dummy values */ +void eth_dev_fp_ops_reset(struct rte_eth_fp_ops *fpo); + +/* setup eth 'fast' API to ethdev values */ +void eth_dev_fp_ops_setup(struct rte_eth_fp_ops *fpo, + const struct rte_eth_dev *dev); + #endif /* _ETH_PRIVATE_H_ */ diff --git a/lib/ethdev/rte_ethdev.c b/lib/ethdev/rte_ethdev.c index 424bc260fa..9fbb1bc3db 100644 --- a/lib/ethdev/rte_ethdev.c +++ b/lib/ethdev/rte_ethdev.c @@ -44,6 +44,9 @@ static const char *MZ_RTE_ETH_DEV_DATA = "rte_eth_dev_data"; struct rte_eth_dev rte_eth_devices[RTE_MAX_ETHPORTS]; +/* public 'fast' API */ +struct rte_eth_fp_ops rte_eth_fp_ops[RTE_MAX_ETHPORTS]; + /* spinlock for eth device callbacks */ static rte_spinlock_t eth_dev_cb_lock = RTE_SPINLOCK_INITIALIZER; @@ -1788,6 +1791,9 @@ rte_eth_dev_start(uint16_t port_id) (*dev->dev_ops->link_update)(dev, 0); } + /* expose selection of PMD rx/tx function */ + eth_dev_fp_ops_setup(rte_eth_fp_ops + port_id, dev); + rte_ethdev_trace_start(port_id); return 0; } @@ -1810,6 +1816,9 @@ rte_eth_dev_stop(uint16_t port_id) return 0; } + /* point rx/tx functions to dummy ones */ + eth_dev_fp_ops_reset(rte_eth_fp_ops + port_id); + dev->data->dev_started = 0; ret = (*dev->dev_ops->dev_stop)(dev); rte_ethdev_trace_stop(port_id, ret); @@ -4568,6 +4577,14 @@ rte_eth_mirror_rule_reset(uint16_t port_id, uint8_t rule_id) return eth_err(port_id, (*dev->dev_ops->mirror_rule_reset)(dev, rule_id)); } +RTE_INIT(eth_dev_init_fp_ops) +{ + uint32_t i; + + for (i = 0; i != RTE_DIM(rte_eth_fp_ops); i++) + eth_dev_fp_ops_reset(rte_eth_fp_ops + i); +} + RTE_INIT(eth_dev_init_cb_lists) { uint16_t i; diff --git a/lib/ethdev/rte_ethdev_core.h b/lib/ethdev/rte_ethdev_core.h index 00f27c643a..1335ef8bb2 100644 --- a/lib/ethdev/rte_ethdev_core.h +++ b/lib/ethdev/rte_ethdev_core.h @@ -53,6 +53,51 @@ typedef int (*eth_rx_descriptor_status_t)(void *rxq, uint16_t offset); typedef int (*eth_tx_descriptor_status_t)(void *txq, uint16_t offset); /**< @internal Check the status of a Tx descriptor */ +/** + * @internal + * Structure used to hold opaque pointernals to internal ethdev RX/TXi + * queues data. + * The main purpose to expose these pointers at all - allow compiler + * to fetch this data for 'fast' ethdev inline functions in advance. + */ +struct rte_ethdev_qdata { + void **data; + /**< points to array of internal queue data pointers */ + void **clbk; + /**< points to array of queue callback data pointers */ +}; + +/** + * @internal + * 'fast' ethdev funcions and related data are hold in a flat array. + * one entry per ethdev. + */ +struct rte_eth_fp_ops { + + /** first 64B line */ + eth_rx_burst_t rx_pkt_burst; + /**< PMD receive function. */ + eth_tx_burst_t tx_pkt_burst; + /**< PMD transmit function. */ + eth_tx_prep_t tx_pkt_prepare; + /**< PMD transmit prepare function. */ + eth_rx_queue_count_t rx_queue_count; + /**< Get the number of used RX descriptors. */ + eth_rx_descriptor_status_t rx_descriptor_status; + /**< Check the status of a Rx descriptor. */ + eth_tx_descriptor_status_t tx_descriptor_status; + /**< Check the status of a Tx descriptor. */ + uintptr_t reserved[2]; + + /** second 64B line */ + struct rte_ethdev_qdata rxq; + struct rte_ethdev_qdata txq; + uintptr_t reserved2[4]; + +} __rte_cache_aligned; + +extern struct rte_eth_fp_ops rte_eth_fp_ops[RTE_MAX_ETHPORTS]; + /** * @internal