service: optimize with C11 atomics

The num_mapped_cores is used as a statistics. Use c11 atomics with
RELAXED ordering for num_mapped_cores instead of rte_atomic ops which
enforce unnessary barriers on aarch64.

Replace execute_lock operations to spinlock_try_lock to avoid duplicate
code.

Signed-off-by: Phil Yang <phil.yang@arm.com>
Reviewed-by: Honnappa Nagarahalli <honnappa.nagarahalli@arm.com>
Acked-by: Harry van Haaren <harry.van.haaren@intel.com>

diff --git a/lib/librte_eal/common/rte_service.c b/lib/librte_eal/common/rte_service.c
index b7164fd..9c1b3ab 100644 (file)
--- a/lib/librte_eal/common/rte_service.c
+++ b/lib/librte_eal/common/rte_service.c
@@ -20,6 +20,7 @@
 #include <rte_atomic.h>
 #include <rte_memory.h>
 #include <rte_malloc.h>
+#include <rte_spinlock.h>
 
 #include "eal_private.h"
 
@@ -38,11 +39,11 @@ struct rte_service_spec_impl {
        /* public part of the struct */
        struct rte_service_spec spec;
 
-       /* atomic lock that when set indicates a service core is currently
+       /* spin lock that when set indicates a service core is currently
         * running this service callback. When not set, a core may take the
         * lock and then run the service callback.
         */
-       rte_atomic32_t execute_lock;
+       rte_spinlock_t execute_lock;
 
        /* API set/get-able variables */
        int8_t app_runstate;
@@ -54,7 +55,7 @@ struct rte_service_spec_impl {
         * It does not indicate the number of cores the service is running
         * on currently.
         */
-       rte_atomic32_t num_mapped_cores;
+       uint32_t num_mapped_cores;
        uint64_t calls;
        uint64_t cycles_spent;
 } __rte_cache_aligned;
@@ -332,7 +333,8 @@ rte_service_runstate_get(uint32_t id)
        rte_smp_rmb();
 
        int check_disabled = !(s->internal_flags & SERVICE_F_START_CHECK);
-       int lcore_mapped = (rte_atomic32_read(&s->num_mapped_cores) > 0);
+       int lcore_mapped = (__atomic_load_n(&s->num_mapped_cores,
+               __ATOMIC_RELAXED) > 0);
 
        return (s->app_runstate == RUNSTATE_RUNNING) &&
                (s->comp_runstate == RUNSTATE_RUNNING) &&
@@ -375,11 +377,11 @@ service_run(uint32_t i, struct core_state *cs, uint64_t service_mask,
        cs->service_active_on_lcore[i] = 1;
 
        if ((service_mt_safe(s) == 0) && (serialize_mt_unsafe == 1)) {
-               if (!rte_atomic32_cmpset((uint32_t *)&s->execute_lock, 0, 1))
+               if (!rte_spinlock_trylock(&s->execute_lock))
                        return -EBUSY;
 
                service_runner_do_callback(s, cs, i);
-               rte_atomic32_clear(&s->execute_lock);
+               rte_spinlock_unlock(&s->execute_lock);
        } else
                service_runner_do_callback(s, cs, i);
 
@@ -415,11 +417,11 @@ rte_service_run_iter_on_app_lcore(uint32_t id, uint32_t serialize_mt_unsafe)
        /* Increment num_mapped_cores to reflect that this core is
         * now mapped capable of running the service.
         */
-       rte_atomic32_inc(&s->num_mapped_cores);
+       __atomic_add_fetch(&s->num_mapped_cores, 1, __ATOMIC_RELAXED);
 
        int ret = service_run(id, cs, UINT64_MAX, s, serialize_mt_unsafe);
 
-       rte_atomic32_dec(&s->num_mapped_cores);
+       __atomic_sub_fetch(&s->num_mapped_cores, 1, __ATOMIC_RELAXED);
 
        return ret;
 }
@@ -555,19 +557,19 @@ service_update(uint32_t sid, uint32_t lcore, uint32_t *set, uint32_t *enabled)
 
                if (*set && !lcore_mapped) {
                        lcore_states[lcore].service_mask |= sid_mask;
-                       rte_atomic32_inc(&rte_services[sid].num_mapped_cores);
+                       __atomic_add_fetch(&rte_services[sid].num_mapped_cores,
+                               1, __ATOMIC_RELAXED);
                }
                if (!*set && lcore_mapped) {
                        lcore_states[lcore].service_mask &= ~(sid_mask);
-                       rte_atomic32_dec(&rte_services[sid].num_mapped_cores);
+                       __atomic_sub_fetch(&rte_services[sid].num_mapped_cores,
+                               1, __ATOMIC_RELAXED);
                }
        }
 
        if (enabled)
                *enabled = !!(lcore_states[lcore].service_mask & (sid_mask));
 
-       rte_smp_wmb();
-
        return 0;
 }
 
@@ -615,7 +617,8 @@ rte_service_lcore_reset_all(void)
                }
        }
        for (i = 0; i < RTE_SERVICE_NUM_MAX; i++)
-               rte_atomic32_set(&rte_services[i].num_mapped_cores, 0);
+               __atomic_store_n(&rte_services[i].num_mapped_cores, 0,
+                       __ATOMIC_RELAXED);
 
        rte_smp_wmb();
 
@@ -698,7 +701,8 @@ rte_service_lcore_stop(uint32_t lcore)
                int32_t enabled = service_mask & (UINT64_C(1) << i);
                int32_t service_running = rte_service_runstate_get(i);
                int32_t only_core = (1 ==
-                       rte_atomic32_read(&rte_services[i].num_mapped_cores));
+                       __atomic_load_n(&rte_services[i].num_mapped_cores,
+                               __ATOMIC_RELAXED));
 
                /* if the core is mapped, and the service is running, and this
                 * is the only core that is mapped, the service would cease to