vcl: cleanup and fixes for vcl test code

- better approximate time when test finishes
- move common vcl and sock test code to vcl_test.h
- overall refactor of variable names

Change-Id: I8e6b43fc017cd05a0ddaa3891767a44fb300c09e
Signed-off-by: Florin Coras <fcoras@cisco.com>

1 files changed, 360 insertions, 56 deletions

diff --git a/src/vcl/vcl_test.h b/src/vcl/vcl_test.h
index 68750af89a1..927110f55d2 100644
--- a/src/vcl/vcl_test.h
+++ b/src/vcl/vcl_test.h
@@ -21,7 +21,6 @@
 #include <stdlib.h>
 #include <string.h>
 #include <vcl/vppcom.h>
-#include <vcl/sock_test_common.h>
 
 #define vtfail(_fn, _rv)						\
 {									\
@@ -46,35 +45,330 @@
 #define vt_atomic_add(_ptr, _val) 					\
   __atomic_fetch_add (_ptr, _val, __ATOMIC_RELEASE)
 
+#define VCL_TEST_TOKEN_HELP           	"#H"
+#define VCL_TEST_TOKEN_EXIT           	"#X"
+#define VCL_TEST_TOKEN_VERBOSE        	"#V"
+#define VCL_TEST_TOKEN_TXBUF_SIZE     	"#T:"
+#define VCL_TEST_TOKEN_NUM_TEST_SESS 	"#I:"
+#define VCL_TEST_TOKEN_NUM_WRITES     	"#N:"
+#define VCL_TEST_TOKEN_RXBUF_SIZE     	"#R:"
+#define VCL_TEST_TOKEN_SHOW_CFG       	"#C"
+#define VCL_TEST_TOKEN_RUN_UNI        	"#U"
+#define VCL_TEST_TOKEN_RUN_BI         	"#B"
+
+#define VCL_TEST_SERVER_PORT         	22000
+#define VCL_TEST_LOCALHOST_IPADDR    	"127.0.0.1"
+
+#define VCL_TEST_CFG_CTRL_MAGIC      	0xfeedface
+#define VCL_TEST_CFG_NUM_WRITES_DEF  	1000000
+#define VCL_TEST_CFG_TXBUF_SIZE_DEF  	8192
+#define VCL_TEST_CFG_RXBUF_SIZE_DEF  	(64*VCL_TEST_CFG_TXBUF_SIZE_DEF)
+#define VCL_TEST_CFG_BUF_SIZE_MIN    	128
+#define VCL_TEST_CFG_MAX_TEST_SESS 	32
+#define VCL_TEST_CFG_MAX_EPOLL_EVENTS 	16
+
+#define VCL_TEST_DELAY_DISCONNECT	1
+#define VCL_TEST_SEPARATOR_STRING 	\
+  "  -----------------------------\n"
+typedef enum
+{
+  VCL_TEST_TYPE_NONE,
+  VCL_TEST_TYPE_ECHO,
+  VCL_TEST_TYPE_UNI,
+  VCL_TEST_TYPE_BI,
+  VCL_TEST_TYPE_EXIT,
+} vcl_test_t;
+
+typedef struct __attribute__ ((packed))
+{
+  uint32_t magic;
+  uint32_t seq_num;
+  uint32_t test;
+  uint32_t ctrl_handle;
+  uint32_t num_test_sessions;
+  uint32_t verbose;
+  uint32_t address_ip6;
+  uint32_t transport_udp;
+  uint64_t rxbuf_size;
+  uint64_t txbuf_size;
+  uint64_t num_writes;
+  uint64_t total_bytes;
+} vcl_test_cfg_t;
+
+typedef struct
+{
+  uint64_t rx_xacts;
+  uint64_t rx_bytes;
+  uint32_t rx_eagain;
+  uint32_t rx_incomp;
+  uint64_t tx_xacts;
+  uint64_t tx_bytes;
+  uint32_t tx_eagain;
+  uint32_t tx_incomp;
+  struct timespec start;
+  struct timespec stop;
+} vcl_test_stats_t;
+
+typedef struct
+{
+  int fd;
+  uint32_t txbuf_size;
+  char *txbuf;
+  uint32_t rxbuf_size;
+  char *rxbuf;
+  vcl_test_cfg_t cfg;
+  vcl_test_stats_t stats;
+} vcl_test_session_t;
+
+static inline void
+vcl_test_stats_accumulate (vcl_test_stats_t * accum, vcl_test_stats_t * incr)
+{
+  accum->rx_xacts += incr->rx_xacts;
+  accum->rx_bytes += incr->rx_bytes;
+  accum->rx_eagain += incr->rx_eagain;
+  accum->rx_incomp += incr->rx_incomp;
+  accum->tx_xacts += incr->tx_xacts;
+  accum->tx_bytes += incr->tx_bytes;
+  accum->tx_eagain += incr->tx_eagain;
+  accum->tx_incomp += incr->tx_incomp;
+}
+
+static inline void
+vcl_test_cfg_init (vcl_test_cfg_t * cfg)
+{
+  cfg->magic = VCL_TEST_CFG_CTRL_MAGIC;
+  cfg->test = VCL_TEST_TYPE_NONE;
+  cfg->ctrl_handle = ~0;
+  cfg->num_test_sessions = 1;
+  cfg->verbose = 0;
+  cfg->rxbuf_size = VCL_TEST_CFG_RXBUF_SIZE_DEF;
+  cfg->num_writes = VCL_TEST_CFG_NUM_WRITES_DEF;
+  cfg->txbuf_size = VCL_TEST_CFG_TXBUF_SIZE_DEF;
+  cfg->total_bytes = cfg->num_writes * cfg->txbuf_size;
+}
+
+static inline int
+vcl_test_cfg_verify (vcl_test_cfg_t * cfg, vcl_test_cfg_t * valid_cfg)
+{
+  /* Note: txbuf & rxbuf on server are the same buffer,
+   *       so txbuf_size is not included in this check.
+   */
+  return ((cfg->magic == valid_cfg->magic)
+	  && (cfg->test == valid_cfg->test)
+	  && (cfg->verbose == valid_cfg->verbose)
+	  && (cfg->rxbuf_size == valid_cfg->rxbuf_size)
+	  && (cfg->num_writes == valid_cfg->num_writes)
+	  && (cfg->total_bytes == valid_cfg->total_bytes));
+}
+
+static inline void
+vcl_test_buf_alloc (vcl_test_cfg_t * cfg, uint8_t is_rxbuf, uint8_t ** buf,
+		    uint32_t * bufsize)
+{
+  uint32_t alloc_size = is_rxbuf ? cfg->rxbuf_size : cfg->txbuf_size;
+  uint8_t *lb = realloc (*buf, (size_t) alloc_size);
+
+  if (lb)
+    {
+      if (is_rxbuf)
+	cfg->rxbuf_size = *bufsize = alloc_size;
+      else
+	cfg->txbuf_size = *bufsize = alloc_size;
+
+      *buf = lb;
+    }
+  else
+    {
+      vtwrn ("realloc failed. using buffer size %d instead of %u",
+	     *bufsize, alloc_size);
+    }
+}
+
+static inline void
+vcl_test_session_buf_alloc (vcl_test_session_t * socket)
+{
+  socket->rxbuf_size = socket->cfg.rxbuf_size;
+  socket->txbuf_size = socket->cfg.txbuf_size;
+  vcl_test_buf_alloc (&socket->cfg, 0 /* is_rxbuf */ ,
+		      (uint8_t **) & socket->txbuf, &socket->txbuf_size);
+  vcl_test_buf_alloc (&socket->cfg, 1 /* is_rxbuf */ ,
+		      (uint8_t **) & socket->rxbuf, &socket->rxbuf_size);
+}
+
+static inline char *
+vcl_test_type_str (vcl_test_t t)
+{
+  switch (t)
+    {
+    case VCL_TEST_TYPE_NONE:
+      return "NONE";
+
+    case VCL_TEST_TYPE_ECHO:
+      return "ECHO";
+
+    case VCL_TEST_TYPE_UNI:
+      return "UNI";
+
+    case VCL_TEST_TYPE_BI:
+      return "BI";
+
+    case VCL_TEST_TYPE_EXIT:
+      return "EXIT";
+
+    default:
+      return "Unknown";
+    }
+}
+
+static inline void
+vcl_test_cfg_dump (vcl_test_cfg_t * cfg, uint8_t is_client)
+{
+  char *spc = "     ";
+
+  printf ("  test config (%p):\n"
+	  VCL_TEST_SEPARATOR_STRING
+	  "                 magic:  0x%08x\n"
+	  "               seq_num:  0x%08x\n"
+	  "%-5s             test:  %s (%d)\n"
+	  "           ctrl handle:  %d (0x%x)\n"
+	  "%-5s num test sockets:  %u (0x%08x)\n"
+	  "%-5s          verbose:  %s (%d)\n"
+	  "%-5s       rxbuf size:  %lu (0x%08lx)\n"
+	  "%-5s       txbuf size:  %lu (0x%08lx)\n"
+	  "%-5s       num writes:  %lu (0x%08lx)\n"
+	  "       client tx bytes:  %lu (0x%08lx)\n"
+	  VCL_TEST_SEPARATOR_STRING,
+	  (void *) cfg, cfg->magic, cfg->seq_num,
+	  is_client && (cfg->test == VCL_TEST_TYPE_UNI) ?
+	  "'" VCL_TEST_TOKEN_RUN_UNI "'" :
+	  is_client && (cfg->test == VCL_TEST_TYPE_BI) ?
+	  "'" VCL_TEST_TOKEN_RUN_BI "'" : spc,
+	  vcl_test_type_str (cfg->test), cfg->test,
+	  cfg->ctrl_handle, cfg->ctrl_handle,
+	  is_client ? "'" VCL_TEST_TOKEN_NUM_TEST_SESS "'" : spc,
+	  cfg->num_test_sessions, cfg->num_test_sessions,
+	  is_client ? "'" VCL_TEST_TOKEN_VERBOSE "'" : spc,
+	  cfg->verbose ? "on" : "off", cfg->verbose,
+	  is_client ? "'" VCL_TEST_TOKEN_RXBUF_SIZE "'" : spc,
+	  cfg->rxbuf_size, cfg->rxbuf_size,
+	  is_client ? "'" VCL_TEST_TOKEN_TXBUF_SIZE "'" : spc,
+	  cfg->txbuf_size, cfg->txbuf_size,
+	  is_client ? "'" VCL_TEST_TOKEN_NUM_WRITES "'" : spc,
+	  cfg->num_writes, cfg->num_writes,
+	  cfg->total_bytes, cfg->total_bytes);
+}
+
+static inline void
+vcl_test_stats_dump (char *header, vcl_test_stats_t * stats,
+		     uint8_t show_rx, uint8_t show_tx, uint8_t verbose)
+{
+  struct timespec diff;
+  double duration, rate;
+  uint64_t total_bytes;
+
+  if ((stats->stop.tv_nsec - stats->start.tv_nsec) < 0)
+    {
+      diff.tv_sec = stats->stop.tv_sec - stats->start.tv_sec - 1;
+      diff.tv_nsec = stats->stop.tv_nsec - stats->start.tv_nsec + 1e9;
+    }
+  else
+    {
+      diff.tv_sec = stats->stop.tv_sec - stats->start.tv_sec;
+      diff.tv_nsec = stats->stop.tv_nsec - stats->start.tv_nsec;
+    }
+  duration = (double) diff.tv_sec + (1e-9 * diff.tv_nsec);
+
+  total_bytes = stats->tx_bytes + stats->rx_bytes;
+  rate = (double) total_bytes *8 / duration / 1e9;
+  printf ("\n%s: Streamed %lu bytes\n"
+	  "  in %lf seconds (%lf Gbps %s-duplex)!\n",
+	  header, total_bytes, duration, rate,
+	  (show_rx && show_tx) ? "full" : "half");
+
+  if (show_tx)
+    {
+      printf (VCL_TEST_SEPARATOR_STRING
+	      "  tx stats (0x%p):\n"
+	      VCL_TEST_SEPARATOR_STRING
+	      "         writes:  %lu (0x%08lx)\n"
+	      "       tx bytes:  %lu (0x%08lx)\n"
+	      "      tx eagain:  %u (0x%08x)\n"
+	      "  tx incomplete:  %u (0x%08x)\n",
+	      (void *) stats, stats->tx_xacts, stats->tx_xacts,
+	      stats->tx_bytes, stats->tx_bytes,
+	      stats->tx_eagain, stats->tx_eagain,
+	      stats->tx_incomp, stats->tx_incomp);
+    }
+  if (show_rx)
+    {
+      printf (VCL_TEST_SEPARATOR_STRING
+	      "  rx stats (0x%p):\n"
+	      VCL_TEST_SEPARATOR_STRING
+	      "          reads:  %lu (0x%08lx)\n"
+	      "       rx bytes:  %lu (0x%08lx)\n"
+	      "      rx eagain:  %u (0x%08x)\n"
+	      "  rx incomplete:  %u (0x%08x)\n",
+	      (void *) stats, stats->rx_xacts, stats->rx_xacts,
+	      stats->rx_bytes, stats->rx_bytes,
+	      stats->rx_eagain, stats->rx_eagain,
+	      stats->rx_incomp, stats->rx_incomp);
+    }
+  if (verbose)
+    printf ("   start.tv_sec:  %ld\n"
+	    "  start.tv_nsec:  %ld\n"
+	    "    stop.tv_sec:  %ld\n"
+	    "   stop.tv_nsec:  %ld\n",
+	    stats->start.tv_sec, stats->start.tv_nsec,
+	    stats->stop.tv_sec, stats->stop.tv_nsec);
+
+  printf (VCL_TEST_SEPARATOR_STRING);
+}
+
 static inline int
-vcl_test_read (int fd, uint8_t *buf, uint32_t nbytes,
-                sock_test_stats_t *stats)
+vcl_comp_tspec (struct timespec *a, struct timespec *b)
+{
+  if (a->tv_sec < b->tv_sec)
+    return -1;
+  else if (a->tv_sec > b->tv_sec)
+    return 1;
+  else if (a->tv_nsec < b->tv_nsec)
+    return -1;
+  else if (a->tv_nsec > b->tv_nsec)
+    return 1;
+  else
+    return 0;
+}
+
+static inline int
+vcl_test_read (int fd, uint8_t * buf, uint32_t nbytes,
+	       vcl_test_stats_t * stats)
 {
   int rx_bytes, errno_val;
-  
+
   do
     {
       if (stats)
-        stats->rx_xacts++;
+	stats->rx_xacts++;
       rx_bytes = vppcom_session_read (fd, buf, nbytes);
 
       if (rx_bytes < 0)
-        {
-          errno = -rx_bytes;
-          rx_bytes = -1;
-        }
+	{
+	  errno = -rx_bytes;
+	  rx_bytes = -1;
+	}
       if (stats)
-        {
-          if ((rx_bytes == 0) ||
-              ((rx_bytes < 0) && ((errno == EAGAIN) || (errno == EWOULDBLOCK))))
-            stats->rx_eagain++;
-          else if (rx_bytes < nbytes)
-            stats->rx_incomp++;
-        }
+	{
+	  if ((rx_bytes == 0) ||
+	      ((rx_bytes < 0)
+	       && ((errno == EAGAIN) || (errno == EWOULDBLOCK))))
+	    stats->rx_eagain++;
+	  else if (rx_bytes < nbytes)
+	    stats->rx_incomp++;
+	}
     }
   while ((rx_bytes == 0) ||
-         ((rx_bytes < 0) && ((errno == EAGAIN) || (errno == EWOULDBLOCK))));
-  
+	 ((rx_bytes < 0) && ((errno == EAGAIN) || (errno == EWOULDBLOCK))));
+
   if (rx_bytes < 0)
     {
       vterr ("vppcom_session_read()", -errno);
@@ -86,30 +380,31 @@ vcl_test_read (int fd, uint8_t *buf, uint32_t nbytes,
 }
 
 static inline int
-vcl_test_read_ds (int fd, vppcom_data_segments_t ds, sock_test_stats_t *stats)
+vcl_test_read_ds (int fd, vppcom_data_segments_t ds, vcl_test_stats_t * stats)
 {
   int rx_bytes, errno_val;
 
   do
     {
       if (stats)
-        stats->rx_xacts++;
+	stats->rx_xacts++;
       rx_bytes = vppcom_session_read_segments (fd, ds);
 
       if (rx_bytes < 0)
-        {
-          errno = -rx_bytes;
-          rx_bytes = -1;
-        }
+	{
+	  errno = -rx_bytes;
+	  rx_bytes = -1;
+	}
       if (stats)
-        {
-          if ((rx_bytes == 0) ||
-              ((rx_bytes < 0) && ((errno == EAGAIN) || (errno == EWOULDBLOCK))))
-            stats->rx_eagain++;
-        }
+	{
+	  if ((rx_bytes == 0) ||
+	      ((rx_bytes < 0)
+	       && ((errno == EAGAIN) || (errno == EWOULDBLOCK))))
+	    stats->rx_eagain++;
+	}
     }
   while ((rx_bytes == 0) ||
-         ((rx_bytes < 0) && ((errno == EAGAIN) || (errno == EWOULDBLOCK))));
+	 ((rx_bytes < 0) && ((errno == EAGAIN) || (errno == EWOULDBLOCK))));
 
   if (rx_bytes < 0)
     {
@@ -122,42 +417,43 @@ vcl_test_read_ds (int fd, vppcom_data_segments_t ds, sock_test_stats_t *stats)
 }
 
 static inline int
-vcl_test_write (int fd, uint8_t *buf, uint32_t nbytes,
-                 sock_test_stats_t *stats, uint32_t verbose)
+vcl_test_write (int fd, uint8_t * buf, uint32_t nbytes,
+		vcl_test_stats_t * stats, uint32_t verbose)
 {
   int tx_bytes = 0, nbytes_left = nbytes, rv;
 
   do
     {
       if (stats)
-        stats->tx_xacts++;
+	stats->tx_xacts++;
       rv = vppcom_session_write (fd, buf, nbytes_left);
       if (rv < 0)
-        {
-          errno = -rv;
-          rv = -1;
-        }
+	{
+	  errno = -rv;
+	  rv = -1;
+	}
       if (rv < 0)
-        {
-          if ((errno == EAGAIN) || (errno == EWOULDBLOCK))
-            {
-              if (stats)
-                stats->tx_eagain++;
-              continue;
-            }
-          else
-            break;
-        }
+	{
+	  if ((errno == EAGAIN) || (errno == EWOULDBLOCK))
+	    {
+	      if (stats)
+		stats->tx_eagain++;
+	      continue;
+	    }
+	  else
+	    break;
+	}
       tx_bytes += rv;
-     
+
       if (tx_bytes != nbytes)
-        {
-          nbytes_left = nbytes_left - rv;
-          if (stats)
-            stats->tx_incomp++;
-        }
-     
-    } while (tx_bytes != nbytes);
+	{
+	  nbytes_left = nbytes_left - rv;
+	  if (stats)
+	    stats->tx_incomp++;
+	}
+
+    }
+  while (tx_bytes != nbytes);
 
   if (tx_bytes < 0)
     {
@@ -165,8 +461,16 @@ vcl_test_write (int fd, uint8_t *buf, uint32_t nbytes,
     }
   else if (stats)
     stats->tx_bytes += tx_bytes;
-  
+
   return (tx_bytes);
 }
 
 #endif /* __vcl_test_h__ */
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */