tas,libtas: use cycles for poll cycle delays

FreakyPenguin · FreakyPenguin · commit 6b7f5a2be131 · 2020-04-17T14:18:59.000+02:00
This should guarantee that both sides are measuring the same way
diff --git a/include/tas_memif.h b/include/tas_memif.h
@@ -63,9 +63,9 @@ struct flexnic_info {
   /** export mac address */
   uint64_t mac_address;
   /** Cycles to poll before blocking for application */
-  uint32_t poll_cycle_app;
+  uint64_t poll_cycle_app;
   /** Cycles to poll before blocking for TAS */
-  uint32_t poll_cycle_tas;
+  uint64_t poll_cycle_tas;
   /** Number of queues in queue manager */
   uint32_t qmq_num;
   /** Number of cores in flexnic emulator */
@@ -212,9 +212,9 @@ struct flextcp_pl_appctx {
 
   /********************************************************/
   /* read-write fields */
+  uint64_t last_ts;
   uint32_t rx_head;
   uint32_t tx_head;
-  uint32_t last_ts;
   uint32_t rx_avail;
 } __attribute__((packed));
 
diff --git a/lib/tas/include/tas_ll.h b/lib/tas/include/tas_ll.h
@@ -64,7 +64,8 @@ struct flextcp_context {
     uint32_t rxq_head;
     uint32_t txq_tail;
     uint32_t txq_avail;
-    uint32_t last_ts;
+    uint32_t _pad;
+    uint64_t last_ts;
   } queues[FLEXTCP_MAX_FTCPCORES];
 
   /* list of connections with pending updates for NIC */
@@ -80,7 +81,7 @@ struct flextcp_context {
   uint16_t next_queue;
 
   /* waiting */
-  uint32_t last_inev_ts;
+  uint64_t last_inev_ts;
   int evfd;
 };
 
diff --git a/lib/tas/init.c b/lib/tas/init.c
@@ -495,7 +495,7 @@ int flextcp_context_tx_alloc(struct flextcp_context *ctx,
 
 static void flextcp_flexnic_kick(struct flextcp_context *ctx, int core)
 {
-  uint32_t now = util_timeout_time_us();
+  uint64_t now = util_rdtsc();
 
   if(now - ctx->queues[core].last_ts > flexnic_info->poll_cycle_tas) {
     // Kick
@@ -941,9 +941,7 @@ int flextcp_context_canwait(struct flextcp_context *ctx)
 
   if ((ctx->flags & CTX_FLAG_WANTWAIT) != 0) {
     /* in want wait state: just wait for grace period to be over */
-    if ((util_timeout_time_us() - ctx->last_inev_ts) >
-        flexnic_info->poll_cycle_app)
-    {
+    if ((util_rdtsc() - ctx->last_inev_ts) > flexnic_info->poll_cycle_app) {
       /* past grace period, move on to lastwait. clear polled flag, to make sure
        * it gets polled again before we clear lastwait. */
       ctx->flags &= ~(CTX_FLAG_POLL_CALLED | CTX_FLAG_WANTWAIT);
@@ -958,7 +956,7 @@ int flextcp_context_canwait(struct flextcp_context *ctx)
     }
   } else {
     /* not currently getting ready to wait, so start */
-    ctx->last_inev_ts = util_timeout_time_us();
+    ctx->last_inev_ts = util_rdtsc();
     ctx->flags |= CTX_FLAG_WANTWAIT;
   }
 
diff --git a/lib/tas/kernel.c b/lib/tas/kernel.c
@@ -41,8 +41,8 @@ static int kernel_evfd = 0;
 
 void flextcp_kernel_kick(void)
 {
-  static uint32_t __thread last_ts = 0;
-  uint32_t now = util_timeout_time_us();
+  static uint64_t __thread last_ts = 0;
+  uint64_t now = util_rdtsc();
 
   /* fprintf(stderr, "kicking kernel?\n"); */
 
diff --git a/tas/blocking.c b/tas/blocking.c
@@ -28,62 +28,61 @@
 #include <unistd.h>
 
 #include <tas.h>
-#include <utils_timeout.h>
 
 extern int kernel_notifyfd;
 
-static void notify_core(int cfd, uint32_t *last_ts, uint32_t ts_us,
-    uint32_t delta)
+static void notify_core(int cfd, uint64_t *last_ts, uint64_t tsc,
+    uint64_t delta)
 {
   uint64_t val;
 
-  if(ts_us - *last_ts > delta) {
+  if(tsc - *last_ts > delta) {
     val = 1;
     if (write(cfd, &val, sizeof(uint64_t)) != sizeof(uint64_t)) {
       perror("notify_core: write failed");
       abort();
     }
   }
 
-  *last_ts = ts_us;
+  *last_ts = tsc;
 }
 
 void notify_fastpath_core(unsigned core)
 {
   notify_core(fp_state->kctx[core].evfd, &fp_state->kctx[core].last_ts,
-      util_timeout_time_us(), tas_info->poll_cycle_tas);
+      util_rdtsc(), tas_info->poll_cycle_tas);
 }
 
-void notify_app_core(int appfd, uint32_t *last_ts)
+void notify_app_core(int appfd, uint64_t *last_ts)
 {
-  notify_core(appfd, last_ts, util_timeout_time_us(), tas_info->poll_cycle_app);
+  notify_core(appfd, last_ts, util_rdtsc(), tas_info->poll_cycle_app);
 }
 
-void notify_appctx(struct flextcp_pl_appctx *ctx, uint32_t ts_us)
+void notify_appctx(struct flextcp_pl_appctx *ctx, uint64_t tsc)
 {
-  notify_core(ctx->evfd, &ctx->last_ts, ts_us, tas_info->poll_cycle_app);
+  notify_core(ctx->evfd, &ctx->last_ts, tsc, tas_info->poll_cycle_app);
 }
 
 void notify_slowpath_core(void)
 {
-  static uint32_t __thread last_ts = 0;
-  notify_core(kernel_notifyfd, &last_ts, util_timeout_time_us(),
+  static uint64_t __thread last_ts = 0;
+  notify_core(kernel_notifyfd, &last_ts, util_rdtsc(),
       tas_info->poll_cycle_tas);
 }
 
-int notify_canblock(struct notify_blockstate *nbs, int had_data, uint32_t ts)
+int notify_canblock(struct notify_blockstate *nbs, int had_data, uint64_t tsc)
 {
   if (had_data) {
     /* not idle this round, reset everything */
     nbs->can_block = nbs->second_bar = 0;
-    nbs->last_active_ts = ts;
+    nbs->last_active_ts = tsc;
   } else if (nbs->second_bar) {
     /* we can block now, reset afterwards */
     nbs->can_block = nbs->second_bar = 0;
-    nbs->last_active_ts = ts;
+    nbs->last_active_ts = tsc;
     return 1;
   } else if (nbs->can_block &&
-      ts - nbs->last_active_ts > tas_info->poll_cycle_tas)
+      tsc - nbs->last_active_ts > tas_info->poll_cycle_tas)
   {
     /* we've reached the poll cycle interval, so just poll once more */
     nbs->second_bar = 1;
diff --git a/tas/fast/fastemu.c b/tas/fast/fastemu.c
@@ -55,7 +55,8 @@
 
 
 static void dataplane_block(struct dataplane_context *ctx, uint32_t ts);
-static unsigned poll_rx(struct dataplane_context *ctx, uint32_t ts) __attribute__((noinline));
+static unsigned poll_rx(struct dataplane_context *ctx, uint32_t ts,
+    uint64_t tsc) __attribute__((noinline));
 static unsigned poll_queues(struct dataplane_context *ctx, uint32_t ts)  __attribute__((noinline));
 static unsigned poll_kernel(struct dataplane_context *ctx, uint32_t ts) __attribute__((noinline));
 static unsigned poll_qman(struct dataplane_context *ctx, uint32_t ts) __attribute__((noinline));
@@ -72,7 +73,7 @@ static inline void tx_flush(struct dataplane_context *ctx);
 static inline void tx_send(struct dataplane_context *ctx,
     struct network_buf_handle *nbh, uint16_t off, uint16_t len);
 
-static void arx_cache_flush(struct dataplane_context *ctx, uint32_t ts) __attribute__((noinline));
+static void arx_cache_flush(struct dataplane_context *ctx, uint64_t tsc) __attribute__((noinline));
 
 int dataplane_init(void)
 {
@@ -159,7 +160,7 @@ void dataplane_loop(struct dataplane_context *ctx)
     ts = qman_timestamp(cyc);
 
     STATS_TS(start);
-    n += poll_rx(ctx, ts);
+    n += poll_rx(ctx, ts, cyc);
     STATS_TS(rx);
     tx_flush(ctx);
 
@@ -181,7 +182,7 @@ void dataplane_loop(struct dataplane_context *ctx)
       poll_scale(ctx);
 
     was_idle = (n == 0);
-    if (config.fp_interrupts && notify_canblock(&nbs, !was_idle, ts)) {
+    if (config.fp_interrupts && notify_canblock(&nbs, !was_idle, cyc)) {
       dataplane_block(ctx, ts);
       notify_canblock_reset(&nbs);
     }
@@ -252,7 +253,8 @@ void dataplane_dump_stats(void)
 }
 #endif
 
-static unsigned poll_rx(struct dataplane_context *ctx, uint32_t ts)
+static unsigned poll_rx(struct dataplane_context *ctx, uint32_t ts,
+    uint64_t tsc)
 {
   int ret;
   unsigned i, n;
@@ -307,7 +309,7 @@ static unsigned poll_rx(struct dataplane_context *ctx, uint32_t ts)
     }
   }
 
-  arx_cache_flush(ctx, ts);
+  arx_cache_flush(ctx, tsc);
 
   /* free received buffers */
   for (i = 0; i < n; i++) {
@@ -589,7 +591,7 @@ static void poll_scale(struct dataplane_context *ctx)
   fp_scale_to = 0;
 }
 
-static void arx_cache_flush(struct dataplane_context *ctx, uint32_t ts)
+static void arx_cache_flush(struct dataplane_context *ctx, uint64_t tsc)
 {
   uint16_t i;
   struct flextcp_pl_appctx *actx;
@@ -614,7 +616,7 @@ static void arx_cache_flush(struct dataplane_context *ctx, uint32_t ts)
 
   for (i = 0; i < ctx->arx_num; i++) {
     actx = &fp_state->appctx[ctx->id][ctx->arx_ctx[i]];
-    notify_appctx(actx, ts);
+    notify_appctx(actx, tsc);
   }
 
   ctx->arx_num = 0;
diff --git a/tas/include/tas.h b/tas/include/tas.h
@@ -60,16 +60,16 @@ void network_cleanup(void);
 void *util_create_shmsiszed(const char *name, size_t size, void *addr);
 
 struct notify_blockstate {
-  uint32_t last_active_ts;
+  uint64_t last_active_ts;
   int can_block;
   int second_bar;
 };
 
 void notify_fastpath_core(unsigned core);
-void notify_appctx(struct flextcp_pl_appctx *ctx, uint32_t ts_us);
-void notify_app_core(int appfd, uint32_t *last_ts);
+void notify_appctx(struct flextcp_pl_appctx *ctx, uint64_t tsc);
+void notify_app_core(int appfd, uint64_t *last_tsc);
 void notify_slowpath_core(void);
-int notify_canblock(struct notify_blockstate *nbs, int had_data, uint32_t ts);
+int notify_canblock(struct notify_blockstate *nbs, int had_data, uint64_t tsc);
 void notify_canblock_reset(struct notify_blockstate *nbs);
 
 /* should become config options */
diff --git a/tas/shm.c b/tas/shm.c
@@ -37,6 +37,7 @@
 #include <utils.h>
 #include <rte_config.h>
 #include <rte_malloc.h>
+#include <rte_cycles.h>
 
 #include <tas.h>
 #include <tas_memif.h>
@@ -53,6 +54,8 @@ static void *util_create_shmsiszed_huge(const char *name, size_t size,
 /* destroy shared huge page memory region */
 static void destroy_shm_huge(const char *name, size_t size, void *addr)
     __attribute__((used));
+/* convert microseconds to cycles */
+static uint64_t us_to_cycles(uint32_t us);
 
 /* Allocate DMA memory before DPDK grabs all huge pages */
 int shm_preinit(void)
@@ -104,8 +107,8 @@ int shm_init(unsigned num)
   tas_info->qmq_num = FLEXNIC_NUM_QMQUEUES;
   tas_info->cores_num = num;
   tas_info->mac_address = 0;
-  tas_info->poll_cycle_app = config.fp_poll_interval_app;
-  tas_info->poll_cycle_tas = config.fp_poll_interval_tas;
+  tas_info->poll_cycle_app = us_to_cycles(config.fp_poll_interval_app);
+  tas_info->poll_cycle_tas = us_to_cycles(config.fp_poll_interval_tas);
 
   if (config.fp_hugepages)
     tas_info->flags |= FLEXNIC_FLAG_HUGEPAGES;
@@ -237,3 +240,9 @@ static void destroy_shm_huge(const char *name, size_t size, void *addr)
   }
   unlink(path);
 }
+
+static uint64_t us_to_cycles(uint32_t us)
+{
+  return (rte_get_tsc_hz() * us) / 1000000;
+}
+
diff --git a/tas/slow/appif.h b/tas/slow/appif.h
@@ -52,7 +52,7 @@ struct app_context {
   struct app_doorbell *doorbell;
 
   int ready, evfd;
-  uint32_t last_ts;
+  uint64_t last_ts;
   struct app_context *next;
 
   struct {
diff --git a/tas/slow/kernel.c b/tas/slow/kernel.c
@@ -132,7 +132,7 @@ int slowpath_main(void)
       loadmon_ts = cur_ts;
     }
 
-    if (notify_canblock(&nbs, n != 0, cur_ts)) {
+    if (notify_canblock(&nbs, n != 0, util_rdtsc())) {
       slowpath_block(cur_ts);
       notify_canblock_reset(&nbs);
     }
diff --git a/tests/tas_unit/fastpath.c b/tests/tas_unit/fastpath.c
@@ -59,7 +59,7 @@ int qman_set(struct qman_thread *t, uint32_t id, uint32_t rate, uint32_t avail,
   return 0;
 }
 
-void notify_fastpath_core(unsigned core, uint32_t ts_us)
+void notify_fastpath_core(unsigned core)
 {
   printf("notify_fastpath_core(%u)\n", core);
 }
diff --git a/tests/testutils.c b/tests/testutils.c
@@ -64,7 +64,7 @@ int test_subcase(const char *name, void (*run)(void *), void *param)
         printf("  [passed]\n");
         return 0;
       } else {
-        printf("  [failed]\n");
+        printf("  [failed] %d %d\n", WIFEXITED(status), WEXITSTATUS(status));
         return -1;
       }
     } else {

Original file line number	Diff line number	Diff line change
`@@ -41,8 +41,8 @@ static int kernel_evfd = 0;`
`41`	`41`
`42`	`42`	`void flextcp_kernel_kick(void)`
`43`	`43`	`{`
`44`		`- static uint32_t __thread last_ts = 0;`
`45`		`- uint32_t now = util_timeout_time_us();`
	`44`	`+ static uint64_t __thread last_ts = 0;`
	`45`	`+ uint64_t now = util_rdtsc();`
`46`	`46`
`47`	`47`	`/* fprintf(stderr, "kicking kernel?\n"); */`
`48`	`48`
Original file line number	Diff line number	Diff line change
`@@ -28,62 +28,61 @@`
`28`	`28`	`#include <unistd.h>`
`29`	`29`
`30`	`30`	`#include <tas.h>`
`31`		`-#include <utils_timeout.h>`
`32`	`31`
`33`	`32`	`extern int kernel_notifyfd;`
`34`	`33`
`35`		`-static void notify_core(int cfd, uint32_t *last_ts, uint32_t ts_us,`
`36`		`- uint32_t delta)`
	`34`	`+static void notify_core(int cfd, uint64_t *last_ts, uint64_t tsc,`
	`35`	`+ uint64_t delta)`
`37`	`36`	`{`
`38`	`37`	`uint64_t val;`
`39`	`38`
`40`		`- if(ts_us - *last_ts > delta) {`
	`39`	`+ if(tsc - *last_ts > delta) {`
`41`	`40`	`val = 1;`
`42`	`41`	`if (write(cfd, &val, sizeof(uint64_t)) != sizeof(uint64_t)) {`
`43`	`42`	`perror("notify_core: write failed");`
`44`	`43`	`abort();`
`45`	`44`	`}`
`46`	`45`	`}`
`47`	`46`
`48`		`- *last_ts = ts_us;`
	`47`	`+ *last_ts = tsc;`
`49`	`48`	`}`
`50`	`49`
`51`	`50`	`void notify_fastpath_core(unsigned core)`
`52`	`51`	`{`
`53`	`52`	`notify_core(fp_state->kctx[core].evfd, &fp_state->kctx[core].last_ts,`
`54`		`- util_timeout_time_us(), tas_info->poll_cycle_tas);`
	`53`	`+ util_rdtsc(), tas_info->poll_cycle_tas);`
`55`	`54`	`}`
`56`	`55`
`57`		`-void notify_app_core(int appfd, uint32_t *last_ts)`
	`56`	`+void notify_app_core(int appfd, uint64_t *last_ts)`
`58`	`57`	`{`
`59`		`- notify_core(appfd, last_ts, util_timeout_time_us(), tas_info->poll_cycle_app);`
	`58`	`+ notify_core(appfd, last_ts, util_rdtsc(), tas_info->poll_cycle_app);`
`60`	`59`	`}`
`61`	`60`
`62`		`-void notify_appctx(struct flextcp_pl_appctx *ctx, uint32_t ts_us)`
	`61`	`+void notify_appctx(struct flextcp_pl_appctx *ctx, uint64_t tsc)`
`63`	`62`	`{`
`64`		`- notify_core(ctx->evfd, &ctx->last_ts, ts_us, tas_info->poll_cycle_app);`
	`63`	`+ notify_core(ctx->evfd, &ctx->last_ts, tsc, tas_info->poll_cycle_app);`
`65`	`64`	`}`
`66`	`65`
`67`	`66`	`void notify_slowpath_core(void)`
`68`	`67`	`{`
`69`		`- static uint32_t __thread last_ts = 0;`
`70`		`- notify_core(kernel_notifyfd, &last_ts, util_timeout_time_us(),`
	`68`	`+ static uint64_t __thread last_ts = 0;`
	`69`	`+ notify_core(kernel_notifyfd, &last_ts, util_rdtsc(),`
`71`	`70`	`tas_info->poll_cycle_tas);`
`72`	`71`	`}`
`73`	`72`
`74`		`-int notify_canblock(struct notify_blockstate *nbs, int had_data, uint32_t ts)`
	`73`	`+int notify_canblock(struct notify_blockstate *nbs, int had_data, uint64_t tsc)`
`75`	`74`	`{`
`76`	`75`	`if (had_data) {`
`77`	`76`	`/* not idle this round, reset everything */`
`78`	`77`	`nbs->can_block = nbs->second_bar = 0;`
`79`		`- nbs->last_active_ts = ts;`
	`78`	`+ nbs->last_active_ts = tsc;`
`80`	`79`	`} else if (nbs->second_bar) {`
`81`	`80`	`/* we can block now, reset afterwards */`
`82`	`81`	`nbs->can_block = nbs->second_bar = 0;`
`83`		`- nbs->last_active_ts = ts;`
	`82`	`+ nbs->last_active_ts = tsc;`
`84`	`83`	`return 1;`
`85`	`84`	`} else if (nbs->can_block &&`
`86`		`- ts - nbs->last_active_ts > tas_info->poll_cycle_tas)`
	`85`	`+ tsc - nbs->last_active_ts > tas_info->poll_cycle_tas)`
`87`	`86`	`{`
`88`	`87`	`/* we've reached the poll cycle interval, so just poll once more */`
`89`	`88`	`nbs->second_bar = 1;`
Original file line number	Diff line number	Diff line change
`@@ -132,7 +132,7 @@ int slowpath_main(void)`
`132`	`132`	`loadmon_ts = cur_ts;`
`133`	`133`	`}`
`134`	`134`
`135`		`- if (notify_canblock(&nbs, n != 0, cur_ts)) {`
	`135`	`+ if (notify_canblock(&nbs, n != 0, util_rdtsc())) {`
`136`	`136`	`slowpath_block(cur_ts);`
`137`	`137`	`notify_canblock_reset(&nbs);`
`138`	`138`	`}`
Original file line number	Diff line number	Diff line change
`@@ -59,7 +59,7 @@ int qman_set(struct qman_thread *t, uint32_t id, uint32_t rate, uint32_t avail,`
`59`	`59`	`return 0;`
`60`	`60`	`}`
`61`	`61`
`62`		`-void notify_fastpath_core(unsigned core, uint32_t ts_us)`
	`62`	`+void notify_fastpath_core(unsigned core)`
`63`	`63`	`{`
`64`	`64`	`printf("notify_fastpath_core(%u)\n", core);`
`65`	`65`	`}`
Original file line number	Diff line number	Diff line change
`@@ -64,7 +64,7 @@ int test_subcase(const char name, void (run)(void ), void param)`
`64`	`64`	`printf(" [passed]\n");`
`65`	`65`	`return 0;`
`66`	`66`	`} else {`
`67`		`- printf(" [failed]\n");`
	`67`	`+ printf(" [failed] %d %d\n", WIFEXITED(status), WEXITSTATUS(status));`
`68`	`68`	`return -1;`
`69`	`69`	`}`
`70`	`70`	`} else {`