From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from dpdk.org (dpdk.org [92.243.14.124]) by inbox.dpdk.org (Postfix) with ESMTP id 79B69A04B7; Wed, 14 Oct 2020 13:44:43 +0200 (CEST) Received: from [92.243.14.124] (localhost [127.0.0.1]) by dpdk.org (Postfix) with ESMTP id 5D4C91DDDB; Wed, 14 Oct 2020 13:44:42 +0200 (CEST) Received: from shelob.oktetlabs.ru (shelob.oktetlabs.ru [91.220.146.113]) by dpdk.org (Postfix) with ESMTP id 5E8991DC47 for ; Wed, 14 Oct 2020 13:44:39 +0200 (CEST) Received: from [192.168.38.17] (aros.oktetlabs.ru [192.168.38.17]) (using TLSv1.3 with cipher TLS_AES_128_GCM_SHA256 (128/128 bits) key-exchange X25519 server-signature RSA-PSS (2048 bits) server-digest SHA256) (No client certificate requested) by shelob.oktetlabs.ru (Postfix) with ESMTPSA id B5DFF7F476; Wed, 14 Oct 2020 14:44:37 +0300 (MSK) DKIM-Filter: OpenDKIM Filter v2.11.0 shelob.oktetlabs.ru B5DFF7F476 DKIM-Signature: v=1; a=rsa-sha256; c=simple/simple; d=oktetlabs.ru; s=default; t=1602675877; bh=nkPIYtPbthpoQC/uUISeV44VpvumHaGn1NQyu4SZZrU=; h=Subject:To:Cc:References:From:Date:In-Reply-To; b=AA6ei6fqFjg/PQ9WqQRGPTCDQCYMFk96/Gw4AQQkLS2ysI/+EAqpkhY0Hpw08jE/U uLEpLQd7TidYfhPxKOwXYymC06ZYsHHEn1w5O0PsOG0x6sQGi2M5mTtyVnRRcG2IvJ TtkBV6vozcKrdngT9OBqZxy++x8ooSlEOyGWuy0A= To: Andrey Vesnovaty , dev@dpdk.org Cc: jer@marvell.com, jerinjacobk@gmail.com, thomas@monjalon.net, ferruh.yigit@intel.com, stephen@networkplumber.org, bruce.richardson@intel.com, orika@nvidia.com, viacheslavo@nvidia.com, andrey.vesnovaty@gmail.com, mdr@ashroe.eu, nhorman@tuxdriver.com, ajit.khaparde@broadcom.com, samik.gupta@broadcom.com References: <20200702120511.16315-1-andreyv@mellanox.com> <20201014114015.17197-1-andreyv@nvidia.com> <20201014114015.17197-2-andreyv@nvidia.com> From: Andrew Rybchenko Organization: OKTET Labs Message-ID: Date: Wed, 14 Oct 2020 14:44:37 +0300 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:78.0) Gecko/20100101 Thunderbird/78.3.1 MIME-Version: 1.0 In-Reply-To: <20201014114015.17197-2-andreyv@nvidia.com> Content-Type: text/plain; charset=utf-8 Content-Language: en-US Content-Transfer-Encoding: 7bit Subject: Re: [dpdk-dev] [PATCH v8 1/2] ethdev: add shared actions to flow API X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.15 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" On 10/14/20 2:40 PM, Andrey Vesnovaty wrote: > Introduce extension of flow action API enabling sharing of single > rte_flow_action in multiple flows. The API intended for PMDs, where > multiple HW offloaded flows can reuse the same HW essence/object > representing flow action and modification of such an essence/object > affects all the rules using it. > > Motivation and example > === > Adding or removing one or more queues to RSS used by multiple flow rules > imposes per rule toll for current DPDK flow API; the scenario requires > for each flow sharing cloned RSS action: > - call `rte_flow_destroy()` > - call `rte_flow_create()` with modified RSS action > > API for sharing action and its in-place update benefits: > - reduce the overhead of multiple RSS flow rules reconfiguration > - optimize resource utilization by sharing action across multiple > flows > > Change description > === > > Shared action > === > In order to represent flow action shared by multiple flows new action > type RTE_FLOW_ACTION_TYPE_SHARED is introduced (see `enum > rte_flow_action_type`). > Actually the introduced API decouples action from any specific flow and > enables sharing of single action by its handle across multiple flows. > > Shared action create/use/destroy > === > Shared action may be reused by some or none flow rules at any given > moment, i.e. shared action resides outside of the context of any flow. > Shared action represent HW resources/objects used for action offloading > implementation. > API for shared action create (see `rte_flow_shared_action_create()`): > - should allocate HW resources and make related initializations required > for shared action implementation. > - make necessary preparations to maintain shared access to > the action resources, configuration and state. > API for shared action destroy (see `rte_flow_shared_action_destroy()`) > should release HW resources and make related cleanups required for shared > action implementation. > > In order to share some flow action reuse the handle of type > `struct rte_flow_shared_action` returned by > rte_flow_shared_action_create() as a `conf` field of > `struct rte_flow_action` (see "example" section). > > If some shared action not used by any flow rule all resources allocated > by the shared action can be released by rte_flow_shared_action_destroy() > (see "example" section). The shared action handle passed as argument to > destroy API should not be used any further i.e. result of the usage is > undefined. > > Shared action re-configuration > === > Shared action behavior defined by its configuration can be updated via > rte_flow_shared_action_update() (see "example" section). The shared > action update operation modifies HW related resources/objects allocated > on the action creation. The number of operations performed by the update > operation should not depend on the number of flows sharing the related > action. On return of shared action update API action behavior should be > according to updated configuration for all flows sharing the action. > > Shared action query > === > Provide separate API to query shared action state (see > rte_flow_shared_action_update()). Taking a counter as an example: query > returns value aggregating all counter increments across all flow rules > sharing the counter. This API doesn't query shared action configuration > since it is controlled by rte_flow_shared_action_create() and > rte_flow_shared_action_update() APIs and no supposed to change by other > means. > > example > === > > struct rte_flow_action actions[2]; > struct rte_flow_shared_action_conf conf; > struct rte_flow_action action; > /* skipped: initialize conf and action */ > struct rte_flow_shared_action *handle = > rte_flow_shared_action_create(port_id, &conf, &action, &error); > actions[0].type = RTE_FLOW_ACTION_TYPE_SHARED; > actions[0].conf = handle; > actions[1].type = RTE_FLOW_ACTION_TYPE_END; > /* skipped: init attr0 & pattern0 args */ > struct rte_flow *flow0 = rte_flow_create(port_id, &attr0, pattern0, > actions, error); > /* create more rules reusing shared action */ > struct rte_flow *flow1 = rte_flow_create(port_id, &attr1, pattern1, > actions, error); > /* skipped: for flows 2 till N */ > struct rte_flow *flowN = rte_flow_create(port_id, &attrN, patternN, > actions, error); > /* update shared action */ > struct rte_flow_action updated_action; > /* > * skipped: initialize updated_action according to desired action > * configuration change > */ > rte_flow_shared_action_update(port_id, handle, &updated_action, error); > /* > * from now on all flows 1 till N will act according to configuration of > * updated_action > */ > /* skipped: destroy all flows 1 till N */ > rte_flow_shared_action_destroy(port_id, handle, error); > > Signed-off-by: Andrey Vesnovaty > Acked-by: Ori Kam > Acked-by: Ajit Khaparde Acked-by: Andrew Rybchenko