From patchwork Mon Oct 23 17:16:51 2017 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Van Haaren, Harry" X-Patchwork-Id: 30732 Return-Path: X-Original-To: patchwork@dpdk.org Delivered-To: patchwork@dpdk.org Received: from [92.243.14.124] (localhost [127.0.0.1]) by dpdk.org (Postfix) with ESMTP id 7C52D1B697; Mon, 23 Oct 2017 19:16:43 +0200 (CEST) Received: from mga09.intel.com (mga09.intel.com [134.134.136.24]) by dpdk.org (Postfix) with ESMTP id AAD6C1B67F for ; Mon, 23 Oct 2017 19:16:37 +0200 (CEST) Received: from fmsmga003.fm.intel.com ([10.253.24.29]) by orsmga102.jf.intel.com with ESMTP/TLS/DHE-RSA-AES256-GCM-SHA384; 23 Oct 2017 10:16:36 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.43,424,1503385200"; d="scan'208";a="912830313" Received: from silpixa00398672.ir.intel.com ([10.237.223.128]) by FMSMGA003.fm.intel.com with ESMTP; 23 Oct 2017 10:16:34 -0700 From: Harry van Haaren To: dev@dpdk.org Cc: pbhagavatula@caviumnetworks.com, Harry van Haaren Date: Mon, 23 Oct 2017 18:16:51 +0100 Message-Id: <1508779012-56186-2-git-send-email-harry.van.haaren@intel.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1508779012-56186-1-git-send-email-harry.van.haaren@intel.com> References: <1508779012-56186-1-git-send-email-harry.van.haaren@intel.com> Subject: [dpdk-dev] [PATCH 1/2] service: add function for app lcore to run service 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" This commit adds a new function which allows an application lcore (aka; *not* a dedicated service-lcore) to run a service. This function is required to allow applications to gradually port functionality to using services, while still being able to run ordinary application functions. This requirement became clear when a patch to the existing eventdev/pipeline sample app was modified to use a service-core for scheduling - and that same core should be capable of running the "worker()" function from the application too. This patch refactors the existing running code into a smaller "service_run" function, which can be called by the dedicated service-core loop, and the newly added function. Signed-off-by: Harry van Haaren [1] http://dpdk.org/ml/archives/dev/2017-October/079876.html Acked-by: Pavan Nikhilesh --- lib/librte_eal/bsdapp/eal/rte_eal_version.map | 1 + lib/librte_eal/common/include/rte_service.h | 21 +++++++++ lib/librte_eal/common/rte_service.c | 59 ++++++++++++++++--------- lib/librte_eal/linuxapp/eal/rte_eal_version.map | 1 + 4 files changed, 61 insertions(+), 21 deletions(-) diff --git a/lib/librte_eal/bsdapp/eal/rte_eal_version.map b/lib/librte_eal/bsdapp/eal/rte_eal_version.map index 080896f..ee8dc98 100644 --- a/lib/librte_eal/bsdapp/eal/rte_eal_version.map +++ b/lib/librte_eal/bsdapp/eal/rte_eal_version.map @@ -229,6 +229,7 @@ EXPERIMENTAL { rte_service_map_lcore_set; rte_service_probe_capability; rte_service_reset; + rte_service_run_iter_on_app_lcore; rte_service_runstate_get; rte_service_runstate_set; rte_service_set_stats_enable; diff --git a/lib/librte_eal/common/include/rte_service.h b/lib/librte_eal/common/include/rte_service.h index 21da739..63d3170 100644 --- a/lib/librte_eal/common/include/rte_service.h +++ b/lib/librte_eal/common/include/rte_service.h @@ -211,6 +211,27 @@ int32_t rte_service_runstate_get(uint32_t id); * @warning * @b EXPERIMENTAL: this API may change without prior notice * + * This function runs a service callback from a non-service lcore context. + * The *id* of the service to be run is passed in, and the service-callback + * is executed on the calling lcore immediately if possible. If the service is + * not multi-thread capable and another thread is currently executing it, this + * function returns without running the callback. + * + * Note that any thread calling this function MUST be a DPDK EAL thread, as + * the *rte_lcore_id* function is used to access internal data structures. + * + * @retval 0 Service was run on the calling thread successfully + * @retval -EBUSY Another lcore is executing the service, and it is not a + * multi-thread safe service, so the service was not run on this lcore + * @retval -ENOEXEC Service is not in a runnable state + * @retval -EINVAL Invalid service id + */ +int32_t rte_service_run_iter_on_app_lcore(uint32_t id); + +/** + * @warning + * @b EXPERIMENTAL: this API may change without prior notice + * * Start a service core. * * Starting a core makes the core begin polling. Any services assigned to it diff --git a/lib/librte_eal/common/rte_service.c b/lib/librte_eal/common/rte_service.c index e598e16..4e27f75 100644 --- a/lib/librte_eal/common/rte_service.c +++ b/lib/librte_eal/common/rte_service.c @@ -331,6 +331,42 @@ rte_service_runner_do_callback(struct rte_service_spec_impl *s, s->spec.callback(userdata); } + +static inline int32_t +service_run(uint32_t i, struct core_state *cs, uint64_t service_mask) +{ + if (!service_valid(i)) + return -EINVAL; + struct rte_service_spec_impl *s = &rte_services[i]; + if (s->comp_runstate != RUNSTATE_RUNNING || + s->app_runstate != RUNSTATE_RUNNING || + !(service_mask & (UINT64_C(1) << i))) + return -ENOEXEC; + + /* check do we need cmpset, if MT safe or <= 1 core + * mapped, atomic ops are not required. + */ + const int use_atomics = (service_mt_safe(s) == 0) && + (s->num_mapped_cores > 1); + if (use_atomics) { + if (!rte_atomic32_cmpset((uint32_t *)&s->execute_lock, 0, 1)) + return -EBUSY; + + rte_service_runner_do_callback(s, cs, i); + rte_atomic32_clear(&s->execute_lock); + } else + rte_service_runner_do_callback(s, cs, i); + + return 0; +} + +int32_t rte_service_run_iter_on_app_lcore(uint32_t id) +{ + /* run service on calling core, using all-ones as the service mask */ + struct core_state *cs = &lcore_states[rte_lcore_id()]; + return service_run(id, cs, UINT64_MAX); +} + static int32_t rte_service_runner_func(void *arg) { @@ -343,27 +379,8 @@ rte_service_runner_func(void *arg) const uint64_t service_mask = cs->service_mask; for (i = 0; i < RTE_SERVICE_NUM_MAX; i++) { - if (!service_valid(i)) - continue; - struct rte_service_spec_impl *s = &rte_services[i]; - if (s->comp_runstate != RUNSTATE_RUNNING || - s->app_runstate != RUNSTATE_RUNNING || - !(service_mask & (UINT64_C(1) << i))) - continue; - - /* check do we need cmpset, if MT safe or <= 1 core - * mapped, atomic ops are not required. - */ - const int use_atomics = (service_mt_safe(s) == 0) && - (s->num_mapped_cores > 1); - if (use_atomics) { - uint32_t *lock = (uint32_t *)&s->execute_lock; - if (rte_atomic32_cmpset(lock, 0, 1)) { - rte_service_runner_do_callback(s, cs, i); - rte_atomic32_clear(&s->execute_lock); - } - } else - rte_service_runner_do_callback(s, cs, i); + /* return value ignored as no change to code flow */ + service_run(i, cs, service_mask); } rte_smp_rmb(); diff --git a/lib/librte_eal/linuxapp/eal/rte_eal_version.map b/lib/librte_eal/linuxapp/eal/rte_eal_version.map index c173ccf..c4d2c27 100644 --- a/lib/librte_eal/linuxapp/eal/rte_eal_version.map +++ b/lib/librte_eal/linuxapp/eal/rte_eal_version.map @@ -233,6 +233,7 @@ EXPERIMENTAL { rte_service_map_lcore_set; rte_service_probe_capability; rte_service_reset; + rte_service_run_iter_on_app_lcore; rte_service_runstate_get; rte_service_runstate_set; rte_service_set_stats_enable;