test/spinlock: amortize the cost of getting time

Instead of getting timestamps per iteration, amortize its overhead
can help getting more precise benchmarking results.

Fixes: af75078fece3 ("first public release")
Cc: stable@dpdk.org
Signed-off-by: Gavin Hu <gavin.hu@arm.com>
Reviewed-by: Joyce Kong <joyce.kong@arm.com>
Reviewed-by: Ruifeng Wang <ruifeng.wang@arm.com>
Reviewed-by: Honnappa Nagarahalli <honnappa.nagarahalli@arm.com>
Acked-by: Nipun Gupta <nipun.gupta@nxp.com>
Acked-by: Konstantin Ananyev <konstantin.ananyev@intel.com>

diff --git a/app/test/test_spinlock.c b/app/test/test_spinlock.c
index 6795195..6ac7495 100644 (file)
--- a/app/test/test_spinlock.c
+++ b/app/test/test_spinlock.c
@@ -96,16 +96,16 @@ test_spinlock_recursive_per_core(__attribute__((unused)) void *arg)
 }
 
 static rte_spinlock_t lk = RTE_SPINLOCK_INITIALIZER;
-static uint64_t lock_count[RTE_MAX_LCORE] = {0};
+static uint64_t time_count[RTE_MAX_LCORE] = {0};
 
-#define TIME_MS 100
+#define MAX_LOOP 10000
 
 static int
 load_loop_fn(void *func_param)
 {
        uint64_t time_diff = 0, begin;
        uint64_t hz = rte_get_timer_hz();
-       uint64_t lcount = 0;
+       volatile uint64_t lcount = 0;
        const int use_lock = *(int*)func_param;
        const unsigned lcore = rte_lcore_id();
 
@@ -114,15 +114,15 @@ load_loop_fn(void *func_param)
                while (rte_atomic32_read(&synchro) == 0);
 
        begin = rte_get_timer_cycles();
-       while (time_diff < hz * TIME_MS / 1000) {
+       while (lcount < MAX_LOOP) {
                if (use_lock)
                        rte_spinlock_lock(&lk);
                lcount++;
                if (use_lock)
                        rte_spinlock_unlock(&lk);
-               time_diff = rte_get_timer_cycles() - begin;
        }
-       lock_count[lcore] = lcount;
+       time_diff = rte_get_timer_cycles() - begin;
+       time_count[lcore] = time_diff * 1000000 / hz;
        return 0;
 }
 
@@ -136,14 +136,16 @@ test_spinlock_perf(void)
 
        printf("\nTest with no lock on single core...\n");
        load_loop_fn(&lock);
-       printf("Core [%u] count = %"PRIu64"\n", lcore, lock_count[lcore]);
-       memset(lock_count, 0, sizeof(lock_count));
+       printf("Core [%u] Cost Time = %"PRIu64" us\n", lcore,
+                                               time_count[lcore]);
+       memset(time_count, 0, sizeof(time_count));
 
        printf("\nTest with lock on single core...\n");
        lock = 1;
        load_loop_fn(&lock);
-       printf("Core [%u] count = %"PRIu64"\n", lcore, lock_count[lcore]);
-       memset(lock_count, 0, sizeof(lock_count));
+       printf("Core [%u] Cost Time = %"PRIu64" us\n", lcore,
+                                               time_count[lcore]);
+       memset(time_count, 0, sizeof(time_count));
 
        printf("\nTest with lock on %u cores...\n", rte_lcore_count());
 
@@ -158,11 +160,12 @@ test_spinlock_perf(void)
        rte_eal_mp_wait_lcore();
 
        RTE_LCORE_FOREACH(i) {
-               printf("Core [%u] count = %"PRIu64"\n", i, lock_count[i]);
-               total += lock_count[i];
+               printf("Core [%u] Cost Time = %"PRIu64" us\n", i,
+                                               time_count[i]);
+               total += time_count[i];
        }
 
-       printf("Total count = %"PRIu64"\n", total);
+       printf("Total Cost Time = %"PRIu64" us\n", total);
 
        return 0;
 }