diff options
Diffstat (limited to 'src/plugins/hs_apps/vcl/vcl_test_client.c')
-rw-r--r-- | src/plugins/hs_apps/vcl/vcl_test_client.c | 731 |
1 files changed, 554 insertions, 177 deletions
diff --git a/src/plugins/hs_apps/vcl/vcl_test_client.c b/src/plugins/hs_apps/vcl/vcl_test_client.c index 4a9fb46e5b8..a4a10b562ff 100644 --- a/src/plugins/hs_apps/vcl/vcl_test_client.c +++ b/src/plugins/hs_apps/vcl/vcl_test_client.c @@ -26,18 +26,34 @@ #include <pthread.h> #include <signal.h> -typedef struct +typedef struct vtc_worker_ vcl_test_client_worker_t; +typedef int (vtc_worker_run_fn) (vcl_test_client_worker_t *wrk); + +struct vtc_worker_ { vcl_test_session_t *sessions; vcl_test_session_t *qsessions; uint32_t n_sessions; uint32_t wrk_index; - fd_set wr_fdset; - fd_set rd_fdset; - int max_fd_index; + union + { + struct + { + fd_set wr_fdset; + fd_set rd_fdset; + int max_fd_index; + }; + struct + { + uint32_t epoll_sh; + struct epoll_event ep_evts[VCL_TEST_CFG_MAX_EPOLL_EVENTS]; + vcl_test_session_t *next_to_send; + }; + }; pthread_t thread_handle; - vcl_test_cfg_t cfg; -} vcl_test_client_worker_t; + vtc_worker_run_fn *wrk_run_fn; + hs_test_cfg_t cfg; +}; typedef struct { @@ -46,13 +62,17 @@ typedef struct vppcom_endpt_t server_endpt; uint32_t cfg_seq_num; uint8_t dump_cfg; - vcl_test_t post_test; + hs_test_t post_test; uint8_t proto; uint8_t incremental_stats; uint32_t n_workers; volatile int active_workers; volatile int test_running; - struct sockaddr_storage server_addr; + union + { + struct in_addr v4; + struct in6_addr v6; + } server_addr; } vcl_test_client_main_t; vcl_test_client_main_t vcl_client_main; @@ -65,14 +85,14 @@ vcl_test_main_t vcl_test_main; static int vtc_cfg_sync (vcl_test_session_t * ts) { - vcl_test_cfg_t *rx_cfg = (vcl_test_cfg_t *) ts->rxbuf; + hs_test_cfg_t *rx_cfg = (hs_test_cfg_t *) ts->rxbuf; int rx_bytes, tx_bytes; vt_atomic_add (&ts->cfg.seq_num, 1); if (ts->cfg.verbose) { vtinf ("(fd %d): Sending config to server.", ts->fd); - vcl_test_cfg_dump (&ts->cfg, 1 /* is_client */ ); + hs_test_cfg_dump (&ts->cfg, 1 /* is_client */); } tx_bytes = ts->write (ts, &ts->cfg, sizeof (ts->cfg)); if (tx_bytes < 0) @@ -81,50 +101,48 @@ vtc_cfg_sync (vcl_test_session_t * ts) return tx_bytes; } - rx_bytes = ts->read (ts, ts->rxbuf, sizeof (vcl_test_cfg_t)); + rx_bytes = ts->read (ts, ts->rxbuf, sizeof (hs_test_cfg_t)); if (rx_bytes < 0) return rx_bytes; - if (rx_cfg->magic != VCL_TEST_CFG_CTRL_MAGIC) + if (rx_cfg->magic != HS_TEST_CFG_CTRL_MAGIC) { vtwrn ("(fd %d): Bad server reply cfg -- aborting!", ts->fd); return -1; } - if ((rx_bytes != sizeof (vcl_test_cfg_t)) - || !vcl_test_cfg_verify (rx_cfg, &ts->cfg)) + if ((rx_bytes != sizeof (hs_test_cfg_t)) || + !hs_test_cfg_verify (rx_cfg, &ts->cfg)) { vtwrn ("(fd %d): Invalid config received from server!", ts->fd); - if (rx_bytes != sizeof (vcl_test_cfg_t)) + if (rx_bytes != sizeof (hs_test_cfg_t)) { vtinf ("\tRx bytes %d != cfg size %lu", rx_bytes, - sizeof (vcl_test_cfg_t)); + sizeof (hs_test_cfg_t)); } else { - vcl_test_cfg_dump (rx_cfg, 1 /* is_client */ ); + hs_test_cfg_dump (rx_cfg, 1 /* is_client */); vtinf ("(fd %d): Valid config sent to server.", ts->fd); - vcl_test_cfg_dump (&ts->cfg, 1 /* is_client */ ); + hs_test_cfg_dump (&ts->cfg, 1 /* is_client */); } return -1; } if (ts->cfg.verbose) { vtinf ("(fd %d): Got config back from server.", ts->fd); - vcl_test_cfg_dump (rx_cfg, 1 /* is_client */ ); + hs_test_cfg_dump (rx_cfg, 1 /* is_client */); } return 0; } static int -vtc_connect_test_sessions (vcl_test_client_worker_t * wrk) +vtc_worker_alloc_sessions (vcl_test_client_worker_t *wrk) { - vcl_test_client_main_t *vcm = &vcl_client_main; - vcl_test_main_t *vt = &vcl_test_main; - const vcl_test_proto_vft_t *tp; vcl_test_session_t *ts; uint32_t n_test_sessions; - int i, rv; + struct timespec now; + int i, j; n_test_sessions = wrk->cfg.num_test_sessions; if (n_test_sessions < 1) @@ -148,62 +166,33 @@ vtc_connect_test_sessions (vcl_test_client_worker_t * wrk) return errno; } - tp = vt->protos[vcm->proto]; + clock_gettime (CLOCK_REALTIME, &now); for (i = 0; i < n_test_sessions; i++) { ts = &wrk->sessions[i]; memset (ts, 0, sizeof (*ts)); ts->session_index = i; + ts->old_stats.stop = now; ts->cfg = wrk->cfg; vcl_test_session_buf_alloc (ts); - rv = tp->open (&wrk->sessions[i], &vcm->server_endpt); - if (rv < 0) - return rv; - } - wrk->n_sessions = n_test_sessions; - -done: - vtinf ("All test sessions (%d) connected!", n_test_sessions); - return 0; -} - -static int -vtc_worker_test_setup (vcl_test_client_worker_t * wrk) -{ - vcl_test_cfg_t *cfg = &wrk->cfg; - vcl_test_session_t *ts; - struct timespec now; - uint32_t sidx; - int i, j; - - FD_ZERO (&wrk->wr_fdset); - FD_ZERO (&wrk->rd_fdset); - - clock_gettime (CLOCK_REALTIME, &now); - - for (i = 0; i < cfg->num_test_sessions; i++) - { - ts = &wrk->sessions[i]; - ts->old_stats.stop = now; - switch (cfg->test) + switch (ts->cfg.test) { - case VCL_TEST_TYPE_UNI: - case VCL_TEST_TYPE_BI: + case HS_TEST_TYPE_UNI: + case HS_TEST_TYPE_BI: for (j = 0; j < ts->txbuf_size; j++) ts->txbuf[j] = j & 0xff; break; default: break; } - - FD_SET (vppcom_session_index (ts->fd), &wrk->wr_fdset); - FD_SET (vppcom_session_index (ts->fd), &wrk->rd_fdset); - sidx = vppcom_session_index (ts->fd); - wrk->max_fd_index = vtc_max (sidx, wrk->max_fd_index); } - wrk->max_fd_index += 1; + wrk->n_sessions = n_test_sessions; + +done: + + vtinf ("All test sessions (%d) initialized!", n_test_sessions); return 0; } @@ -227,16 +216,13 @@ vtc_worker_init (vcl_test_client_worker_t * wrk) } vt_atomic_add (&vcm->active_workers, 1); } - rv = vtc_connect_test_sessions (wrk); + rv = vtc_worker_alloc_sessions (wrk); if (rv) { - vterr ("vtc_connect_test_sessions ()", rv); + vterr ("vtc_worker_alloc_sessions ()", rv); return rv; } - if (vtc_worker_test_setup (wrk)) - return -1; - return 0; } @@ -253,8 +239,7 @@ vtc_accumulate_stats (vcl_test_client_worker_t * wrk, while (__sync_lock_test_and_set (&stats_lock, 1)) ; - if (ctrl->cfg.test == VCL_TEST_TYPE_BI - || ctrl->cfg.test == VCL_TEST_TYPE_ECHO) + if (ctrl->cfg.test == HS_TEST_TYPE_BI || ctrl->cfg.test == HS_TEST_TYPE_ECHO) show_rx = 1; for (i = 0; i < wrk->cfg.num_test_sessions; i++) @@ -308,32 +293,90 @@ vtc_inc_stats_check (vcl_test_session_t *ts) } } -static void * -vtc_worker_loop (void *arg) +static void +vtc_worker_start_transfer (vcl_test_client_worker_t *wrk) +{ + vtinf ("Worker %u starting transfer ...", wrk->wrk_index); + + if (wrk->wrk_index == 0) + { + vcl_test_client_main_t *vcm = &vcl_client_main; + vcl_test_session_t *ctrl = &vcm->ctrl_session; + + clock_gettime (CLOCK_REALTIME, &ctrl->stats.start); + } +} + +static int +vtc_session_check_is_done (vcl_test_session_t *ts, uint8_t check_rx) +{ + if ((!check_rx && ts->stats.tx_bytes >= ts->cfg.total_bytes) || + (check_rx && ts->stats.rx_bytes >= ts->cfg.total_bytes)) + { + clock_gettime (CLOCK_REALTIME, &ts->stats.stop); + ts->is_done = 1; + return 1; + } + return 0; +} + +static int +vtc_worker_connect_sessions_select (vcl_test_client_worker_t *wrk) +{ + vcl_test_client_main_t *vcm = &vcl_client_main; + vcl_test_main_t *vt = &vcl_test_main; + const vcl_test_proto_vft_t *tp; + vcl_test_session_t *ts; + uint32_t sidx; + int i, rv; + + tp = vt->protos[vcm->proto]; + + FD_ZERO (&wrk->wr_fdset); + FD_ZERO (&wrk->rd_fdset); + + for (i = 0; i < wrk->cfg.num_test_sessions; i++) + { + ts = &wrk->sessions[i]; + + rv = tp->open (&wrk->sessions[i], &vcm->server_endpt); + if (rv < 0) + return rv; + + FD_SET (vppcom_session_index (ts->fd), &wrk->wr_fdset); + FD_SET (vppcom_session_index (ts->fd), &wrk->rd_fdset); + sidx = vppcom_session_index (ts->fd); + wrk->max_fd_index = vtc_max (sidx, wrk->max_fd_index); + } + wrk->max_fd_index += 1; + + vtinf ("All test sessions (%d) connected!", wrk->cfg.num_test_sessions); + + return 0; +} + +static int +vtc_worker_run_select (vcl_test_client_worker_t *wrk) { vcl_test_client_main_t *vcm = &vcl_client_main; - vcl_test_session_t *ctrl = &vcm->ctrl_session; - vcl_test_client_worker_t *wrk = arg; - uint32_t n_active_sessions; fd_set _wfdset, *wfdset = &_wfdset; fd_set _rfdset, *rfdset = &_rfdset; + uint32_t n_active_sessions; vcl_test_session_t *ts; int i, rv, check_rx = 0; - rv = vtc_worker_init (wrk); + rv = vtc_worker_connect_sessions_select (wrk); if (rv) { - vterr ("vtc_worker_init()", rv); - return 0; + vterr ("vtc_worker_connect_sessions()", rv); + return rv; } - vtinf ("Starting test ..."); + check_rx = wrk->cfg.test != HS_TEST_TYPE_UNI; + n_active_sessions = wrk->cfg.num_test_sessions; - if (wrk->wrk_index == 0) - clock_gettime (CLOCK_REALTIME, &ctrl->stats.start); + vtc_worker_start_transfer (wrk); - check_rx = wrk->cfg.test != VCL_TEST_TYPE_UNI; - n_active_sessions = wrk->cfg.num_test_sessions; while (n_active_sessions && vcm->test_running) { _wfdset = wrk->wr_fdset; @@ -344,7 +387,7 @@ vtc_worker_loop (void *arg) if (rv < 0) { vterr ("vppcom_select()", rv); - goto exit; + break; } else if (rv == 0) continue; @@ -355,29 +398,29 @@ vtc_worker_loop (void *arg) if (ts->is_done) continue; - if (FD_ISSET (vppcom_session_index (ts->fd), rfdset) - && ts->stats.rx_bytes < ts->cfg.total_bytes) + if (FD_ISSET (vppcom_session_index (ts->fd), rfdset) && + ts->stats.rx_bytes < ts->cfg.total_bytes) { rv = ts->read (ts, ts->rxbuf, ts->rxbuf_size); if (rv < 0) - goto exit; + break; } - if (FD_ISSET (vppcom_session_index (ts->fd), wfdset) - && ts->stats.tx_bytes < ts->cfg.total_bytes) + if (FD_ISSET (vppcom_session_index (ts->fd), wfdset) && + ts->stats.tx_bytes < ts->cfg.total_bytes) { rv = ts->write (ts, ts->txbuf, ts->cfg.txbuf_size); if (rv < 0) { vtwrn ("vppcom_test_write (%d) failed -- aborting test", ts->fd); - goto exit; + break; } if (vcm->incremental_stats) vtc_inc_stats_check (ts); } - if ((!check_rx && ts->stats.tx_bytes >= ts->cfg.total_bytes) - || (check_rx && ts->stats.rx_bytes >= ts->cfg.total_bytes)) + if ((!check_rx && ts->stats.tx_bytes >= ts->cfg.total_bytes) || + (check_rx && ts->stats.rx_bytes >= ts->cfg.total_bytes)) { clock_gettime (CLOCK_REALTIME, &ts->stats.stop); ts->is_done = 1; @@ -385,59 +428,343 @@ vtc_worker_loop (void *arg) } } } -exit: + + return 0; +} + +static void +vtc_worker_epoll_send_add (vcl_test_client_worker_t *wrk, + vcl_test_session_t *ts) +{ + if (!wrk->next_to_send) + { + wrk->next_to_send = ts; + } + else + { + ts->next = wrk->next_to_send; + wrk->next_to_send = ts->next; + } +} + +static void +vtc_worker_epoll_send_del (vcl_test_client_worker_t *wrk, + vcl_test_session_t *ts, vcl_test_session_t *prev) +{ + if (!prev) + { + wrk->next_to_send = ts->next; + } + else + { + prev->next = ts->next; + } +} + +static int +vtc_worker_connect_sessions_epoll (vcl_test_client_worker_t *wrk) +{ + vcl_test_client_main_t *vcm = &vcl_client_main; + vcl_test_main_t *vt = &vcl_test_main; + const vcl_test_proto_vft_t *tp; + struct timespec start, end; + uint32_t n_connected = 0; + vcl_test_session_t *ts; + struct epoll_event ev; + int i, ci = 0, rv, n_ev; + double diff; + + tp = vt->protos[vcm->proto]; + wrk->epoll_sh = vppcom_epoll_create (); + + ev.events = EPOLLET | EPOLLOUT; + + clock_gettime (CLOCK_REALTIME, &start); + + while (n_connected < wrk->cfg.num_test_sessions) + { + /* + * Try to connect more sessions if under pending threshold + */ + while ((ci - n_connected) < 16 && ci < wrk->cfg.num_test_sessions) + { + ts = &wrk->sessions[ci]; + ts->noblk_connect = 1; + rv = tp->open (&wrk->sessions[ci], &vcm->server_endpt); + if (rv < 0) + { + vtwrn ("open: %d", rv); + return rv; + } + + ev.data.u64 = ci; + rv = vppcom_epoll_ctl (wrk->epoll_sh, EPOLL_CTL_ADD, ts->fd, &ev); + if (rv < 0) + { + vtwrn ("vppcom_epoll_ctl: %d", rv); + return rv; + } + ci += 1; + } + + /* + * Handle connected events + */ + n_ev = + vppcom_epoll_wait (wrk->epoll_sh, wrk->ep_evts, + VCL_TEST_CFG_MAX_EPOLL_EVENTS, 0 /* timeout */); + if (n_ev < 0) + { + vterr ("vppcom_epoll_wait() returned", n_ev); + return -1; + } + else if (n_ev == 0) + { + continue; + } + + for (i = 0; i < n_ev; i++) + { + ts = &wrk->sessions[wrk->ep_evts[i].data.u32]; + if (!(wrk->ep_evts[i].events & EPOLLOUT)) + { + vtwrn ("connect failed"); + return -1; + } + if (ts->is_open) + { + vtwrn ("connection already open?"); + return -1; + } + ts->is_open = 1; + n_connected += 1; + } + } + + clock_gettime (CLOCK_REALTIME, &end); + + diff = vcl_test_time_diff (&start, &end); + vtinf ("Connected (%u) connected in %.2f seconds (%u CPS)!", + wrk->cfg.num_test_sessions, diff, + (uint32_t) ((double) wrk->cfg.num_test_sessions / diff)); + + ev.events = EPOLLET | EPOLLIN | EPOLLOUT; + + for (i = 0; i < wrk->cfg.num_test_sessions; i++) + { + ts = &wrk->sessions[i]; + + /* No data to be sent */ + if (ts->cfg.total_bytes == 0) + { + n_connected -= 1; + clock_gettime (CLOCK_REALTIME, &ts->stats.stop); + ts->is_done = 1; + continue; + } + + ev.data.u64 = i; + rv = vppcom_epoll_ctl (wrk->epoll_sh, EPOLL_CTL_MOD, ts->fd, &ev); + if (rv < 0) + { + vtwrn ("vppcom_epoll_ctl: %d", rv); + return rv; + } + vtc_worker_epoll_send_add (wrk, ts); + } + + return n_connected; +} + +static int +vtc_worker_run_epoll (vcl_test_client_worker_t *wrk) +{ + vcl_test_client_main_t *vcm = &vcl_client_main; + uint32_t n_active_sessions, max_writes = 16, n_writes = 0; + vcl_test_session_t *ts, *prev = 0; + int i, rv, check_rx = 0, n_ev; + + rv = vtc_worker_connect_sessions_epoll (wrk); + if (rv < 0) + { + vterr ("vtc_worker_connect_sessions()", rv); + return rv; + } + + n_active_sessions = rv; + check_rx = wrk->cfg.test != HS_TEST_TYPE_UNI; + + vtc_worker_start_transfer (wrk); + ts = wrk->next_to_send; + + while (n_active_sessions && vcm->test_running) + { + /* + * Try to write + */ + if (!ts) + { + ts = wrk->next_to_send; + if (!ts) + goto get_epoll_evts; + } + + rv = ts->write (ts, ts->txbuf, ts->cfg.txbuf_size); + if (rv > 0) + { + if (vcm->incremental_stats) + vtc_inc_stats_check (ts); + if (vtc_session_check_is_done (ts, check_rx)) + n_active_sessions -= 1; + } + else if (rv == 0) + { + vtc_worker_epoll_send_del (wrk, ts, prev); + } + else + { + vtwrn ("vppcom_test_write (%d) failed -- aborting test", ts->fd); + return -1; + } + prev = ts; + ts = ts->next; + n_writes += 1; + + if (rv > 0 && n_writes < max_writes) + continue; + + get_epoll_evts: + + /* + * Grab new events + */ + + n_ev = + vppcom_epoll_wait (wrk->epoll_sh, wrk->ep_evts, + VCL_TEST_CFG_MAX_EPOLL_EVENTS, 0 /* timeout */); + if (n_ev < 0) + { + vterr ("vppcom_epoll_wait()", n_ev); + break; + } + else if (n_ev == 0) + { + continue; + } + + for (i = 0; i < n_ev; i++) + { + ts = &wrk->sessions[wrk->ep_evts[i].data.u32]; + + if (ts->is_done) + continue; + + if (wrk->ep_evts[i].events & (EPOLLERR | EPOLLHUP | EPOLLRDHUP)) + { + vtinf ("%u finished before reading all data?", ts->fd); + break; + } + if ((wrk->ep_evts[i].events & EPOLLIN) && + ts->stats.rx_bytes < ts->cfg.total_bytes) + { + rv = ts->read (ts, ts->rxbuf, ts->rxbuf_size); + if (rv < 0) + break; + if (vtc_session_check_is_done (ts, check_rx)) + n_active_sessions -= 1; + } + if ((wrk->ep_evts[i].events & EPOLLOUT) && + ts->stats.tx_bytes < ts->cfg.total_bytes) + { + vtc_worker_epoll_send_add (wrk, ts); + } + } + + n_writes = 0; + } + + return 0; +} + +static inline int +vtc_worker_run (vcl_test_client_worker_t *wrk) +{ + int rv; + + vtinf ("Worker %u starting test ...", wrk->wrk_index); + + rv = wrk->wrk_run_fn (wrk); + vtinf ("Worker %d done ...", wrk->wrk_index); + + return rv; +} + +static void * +vtc_worker_loop (void *arg) +{ + vcl_test_client_main_t *vcm = &vcl_client_main; + vcl_test_session_t *ctrl = &vcm->ctrl_session; + vcl_test_client_worker_t *wrk = arg; + + if (vtc_worker_init (wrk)) + goto done; + + if (vtc_worker_run (wrk)) + goto done; + vtc_accumulate_stats (wrk, ctrl); sleep (VCL_TEST_DELAY_DISCONNECT); vtc_worker_sessions_exit (wrk); + +done: + if (wrk->wrk_index) vt_atomic_add (&vcm->active_workers, -1); + return 0; } static void vtc_print_stats (vcl_test_session_t * ctrl) { - int is_echo = ctrl->cfg.test == VCL_TEST_TYPE_ECHO; + int is_echo = ctrl->cfg.test == HS_TEST_TYPE_ECHO; int show_rx = 0; char buf[64]; - if (ctrl->cfg.test == VCL_TEST_TYPE_BI - || ctrl->cfg.test == VCL_TEST_TYPE_ECHO) + if (ctrl->cfg.test == HS_TEST_TYPE_BI || ctrl->cfg.test == HS_TEST_TYPE_ECHO) show_rx = 1; vcl_test_stats_dump ("CLIENT RESULTS", &ctrl->stats, show_rx, 1 /* show tx */ , ctrl->cfg.verbose); - vcl_test_cfg_dump (&ctrl->cfg, 1 /* is_client */ ); + hs_test_cfg_dump (&ctrl->cfg, 1 /* is_client */); if (ctrl->cfg.verbose) { - vtinf (" ctrl session info\n" - VCL_TEST_SEPARATOR_STRING + vtinf (" ctrl session info\n" HS_TEST_SEPARATOR_STRING " fd: %d (0x%08x)\n" " rxbuf: %p\n" " rxbuf size: %u (0x%08x)\n" " txbuf: %p\n" - " txbuf size: %u (0x%08x)\n" - VCL_TEST_SEPARATOR_STRING, - ctrl->fd, (uint32_t) ctrl->fd, - ctrl->rxbuf, ctrl->rxbuf_size, ctrl->rxbuf_size, - ctrl->txbuf, ctrl->txbuf_size, ctrl->txbuf_size); + " txbuf size: %u (0x%08x)\n" HS_TEST_SEPARATOR_STRING, + ctrl->fd, (uint32_t) ctrl->fd, ctrl->rxbuf, ctrl->rxbuf_size, + ctrl->rxbuf_size, ctrl->txbuf, ctrl->txbuf_size, + ctrl->txbuf_size); } if (is_echo) snprintf (buf, sizeof (buf), "Echo"); else snprintf (buf, sizeof (buf), "%s-directional Stream", - ctrl->cfg.test == VCL_TEST_TYPE_BI ? "Bi" : "Uni"); + ctrl->cfg.test == HS_TEST_TYPE_BI ? "Bi" : "Uni"); } static void vtc_echo_client (vcl_test_client_main_t * vcm) { vcl_test_session_t *ctrl = &vcm->ctrl_session; - vcl_test_cfg_t *cfg = &ctrl->cfg; + hs_test_cfg_t *cfg = &ctrl->cfg; int rv; cfg->total_bytes = strlen (ctrl->txbuf) + 1; @@ -457,12 +784,12 @@ static void vtc_stream_client (vcl_test_client_main_t * vcm) { vcl_test_session_t *ctrl = &vcm->ctrl_session; - vcl_test_cfg_t *cfg = &ctrl->cfg; + hs_test_cfg_t *cfg = &ctrl->cfg; vcl_test_client_worker_t *wrk; uint32_t i, n_conn, n_conn_per_wrk; vtinf ("%s-directional Stream Test Starting!", - ctrl->cfg.test == VCL_TEST_TYPE_BI ? "Bi" : "Uni"); + ctrl->cfg.test == HS_TEST_TYPE_BI ? "Bi" : "Uni"); memset (&ctrl->stats, 0, sizeof (vcl_test_stats_t)); cfg->total_bytes = cfg->num_writes * cfg->txbuf_size; @@ -480,7 +807,7 @@ vtc_stream_client (vcl_test_client_main_t * vcm) } vcm->test_running = 1; - ctrl->cfg.cmd = VCL_TEST_CMD_START; + ctrl->cfg.cmd = HS_TEST_CMD_START; if (vtc_cfg_sync (ctrl)) { vtwrn ("test cfg sync failed -- aborting!"); @@ -490,8 +817,12 @@ vtc_stream_client (vcl_test_client_main_t * vcm) for (i = 1; i < vcm->n_workers; i++) { wrk = &vcm->workers[i]; - pthread_create (&wrk->thread_handle, NULL, vtc_worker_loop, - (void *) wrk); + if (pthread_create (&wrk->thread_handle, NULL, vtc_worker_loop, + (void *) wrk)) + { + vtwrn ("pthread_create failed -- aborting!"); + return; + } } vtc_worker_loop (&vcm->workers[0]); @@ -499,7 +830,7 @@ vtc_stream_client (vcl_test_client_main_t * vcm) ; vtinf ("Sending config on ctrl session (fd %d) for stats...", ctrl->fd); - ctrl->cfg.cmd = VCL_TEST_CMD_STOP; + ctrl->cfg.cmd = HS_TEST_CMD_STOP; if (vtc_cfg_sync (ctrl)) { vtwrn ("test cfg sync failed -- aborting!"); @@ -508,8 +839,8 @@ vtc_stream_client (vcl_test_client_main_t * vcm) vtc_print_stats (ctrl); - ctrl->cfg.cmd = VCL_TEST_CMD_SYNC; - ctrl->cfg.test = VCL_TEST_TYPE_ECHO; + ctrl->cfg.cmd = HS_TEST_CMD_SYNC; + ctrl->cfg.test = HS_TEST_TYPE_ECHO; ctrl->cfg.total_bytes = 0; if (vtc_cfg_sync (ctrl)) vtwrn ("post-test cfg sync failed!"); @@ -529,7 +860,7 @@ cfg_txbuf_size_set (void) ctrl->cfg.total_bytes = ctrl->cfg.num_writes * ctrl->cfg.txbuf_size; vcl_test_buf_alloc (&ctrl->cfg, 0 /* is_rxbuf */ , (uint8_t **) & ctrl->txbuf, &ctrl->txbuf_size); - vcl_test_cfg_dump (&ctrl->cfg, 1 /* is_client */ ); + hs_test_cfg_dump (&ctrl->cfg, 1 /* is_client */); } else vtwrn ("Invalid txbuf size (%lu) < minimum buf size (%u)!", @@ -548,7 +879,7 @@ cfg_num_writes_set (void) { ctrl->cfg.num_writes = num_writes; ctrl->cfg.total_bytes = ctrl->cfg.num_writes * ctrl->cfg.txbuf_size; - vcl_test_cfg_dump (&ctrl->cfg, 1 /* is_client */ ); + hs_test_cfg_dump (&ctrl->cfg, 1 /* is_client */); } else { @@ -568,7 +899,7 @@ cfg_num_test_sessions_set (void) (num_test_sessions <= VCL_TEST_CFG_MAX_TEST_SESS)) { ctrl->cfg.num_test_sessions = num_test_sessions; - vcl_test_cfg_dump (&ctrl->cfg, 1 /* is_client */ ); + hs_test_cfg_dump (&ctrl->cfg, 1 /* is_client */); } else { @@ -590,7 +921,7 @@ cfg_rxbuf_size_set (void) ctrl->cfg.rxbuf_size = rxbuf_size; vcl_test_buf_alloc (&ctrl->cfg, 1 /* is_rxbuf */ , (uint8_t **) & ctrl->rxbuf, &ctrl->rxbuf_size); - vcl_test_cfg_dump (&ctrl->cfg, 1 /* is_client */ ); + hs_test_cfg_dump (&ctrl->cfg, 1 /* is_client */); } else vtwrn ("Invalid rxbuf size (%lu) < minimum buf size (%u)!", @@ -604,20 +935,19 @@ cfg_verbose_toggle (void) vcl_test_session_t *ctrl = &vcm->ctrl_session; ctrl->cfg.verbose = ctrl->cfg.verbose ? 0 : 1; - vcl_test_cfg_dump (&ctrl->cfg, 1 /* is_client */ ); - + hs_test_cfg_dump (&ctrl->cfg, 1 /* is_client */); } -static vcl_test_t +static hs_test_t parse_input () { vcl_test_client_main_t *vcm = &vcl_client_main; vcl_test_session_t *ctrl = &vcm->ctrl_session; - vcl_test_t rv = VCL_TEST_TYPE_NONE; + hs_test_t rv = HS_TEST_TYPE_NONE; if (!strncmp (VCL_TEST_TOKEN_EXIT, ctrl->txbuf, strlen (VCL_TEST_TOKEN_EXIT))) - rv = VCL_TEST_TYPE_EXIT; + rv = HS_TEST_TYPE_EXIT; else if (!strncmp (VCL_TEST_TOKEN_HELP, ctrl->txbuf, strlen (VCL_TEST_TOKEN_HELP))) @@ -647,16 +977,16 @@ parse_input () strlen (VCL_TEST_TOKEN_RXBUF_SIZE))) cfg_rxbuf_size_set (); - else if (!strncmp (VCL_TEST_TOKEN_RUN_UNI, ctrl->txbuf, - strlen (VCL_TEST_TOKEN_RUN_UNI))) - rv = ctrl->cfg.test = VCL_TEST_TYPE_UNI; + else if (!strncmp (HS_TEST_TOKEN_RUN_UNI, ctrl->txbuf, + strlen (HS_TEST_TOKEN_RUN_UNI))) + rv = ctrl->cfg.test = HS_TEST_TYPE_UNI; - else if (!strncmp (VCL_TEST_TOKEN_RUN_BI, ctrl->txbuf, - strlen (VCL_TEST_TOKEN_RUN_BI))) - rv = ctrl->cfg.test = VCL_TEST_TYPE_BI; + else if (!strncmp (HS_TEST_TOKEN_RUN_BI, ctrl->txbuf, + strlen (HS_TEST_TOKEN_RUN_BI))) + rv = ctrl->cfg.test = HS_TEST_TYPE_BI; else - rv = VCL_TEST_TYPE_ECHO; + rv = HS_TEST_TYPE_ECHO; return rv; } @@ -682,6 +1012,7 @@ print_usage_and_exit (void) " -T <txbuf-size> Test Cfg: tx buffer size.\n" " -U Run Uni-directional test.\n" " -B Run Bi-directional test.\n" + " -b <bytes> Total number of bytes transferred\n" " -V Verbose mode.\n" " -I <N> Use N sessions.\n" " -s <N> Use N sessions.\n" @@ -697,7 +1028,7 @@ vtc_process_opts (vcl_test_client_main_t * vcm, int argc, char **argv) int c, v; opterr = 0; - while ((c = getopt (argc, argv, "chnp:w:XE:I:N:R:T:UBV6DLs:q:S")) != -1) + while ((c = getopt (argc, argv, "chnp:w:xXE:I:N:R:T:b:UBV6DLs:q:S")) != -1) switch (c) { case 'c': @@ -752,7 +1083,11 @@ vtc_process_opts (vcl_test_client_main_t * vcm, int argc, char **argv) break; case 'X': - vcm->post_test = VCL_TEST_TYPE_EXIT; + vcm->post_test = HS_TEST_TYPE_EXIT; + break; + + case 'x': + vcm->post_test = HS_TEST_TYPE_NONE; break; case 'E': @@ -763,7 +1098,7 @@ vtc_process_opts (vcl_test_client_main_t * vcm, int argc, char **argv) print_usage_and_exit (); } strncpy (ctrl->txbuf, optarg, ctrl->txbuf_size); - ctrl->cfg.test = VCL_TEST_TYPE_ECHO; + ctrl->cfg.test = HS_TEST_TYPE_ECHO; break; case 'N': @@ -822,13 +1157,28 @@ vtc_process_opts (vcl_test_client_main_t * vcm, int argc, char **argv) print_usage_and_exit (); } break; + case 'b': + if (sscanf (optarg, "0x%lu", &ctrl->cfg.total_bytes) != 1) + if (sscanf (optarg, "%ld", &ctrl->cfg.total_bytes) != 1) + { + vtwrn ("Invalid value for option -%c!", c); + print_usage_and_exit (); + } + if (ctrl->cfg.total_bytes % ctrl->cfg.txbuf_size) + { + vtwrn ("total bytes must be mutliple of txbuf size(0x%lu)!", + ctrl->cfg.txbuf_size); + print_usage_and_exit (); + } + ctrl->cfg.num_writes = ctrl->cfg.total_bytes / ctrl->cfg.txbuf_size; + break; case 'U': - ctrl->cfg.test = VCL_TEST_TYPE_UNI; + ctrl->cfg.test = HS_TEST_TYPE_UNI; break; case 'B': - ctrl->cfg.test = VCL_TEST_TYPE_BI; + ctrl->cfg.test = HS_TEST_TYPE_BI; break; case 'V': @@ -882,9 +1232,9 @@ vtc_process_opts (vcl_test_client_main_t * vcm, int argc, char **argv) print_usage_and_exit (); } - if (argc < (optind + 2)) + if (argc > (optind + 2)) { - vtwrn ("Insufficient number of arguments!"); + vtwrn ("Invalid number of arguments!"); print_usage_and_exit (); } @@ -895,26 +1245,25 @@ vtc_process_opts (vcl_test_client_main_t * vcm, int argc, char **argv) memset (&vcm->server_addr, 0, sizeof (vcm->server_addr)); if (ctrl->cfg.address_ip6) { - struct sockaddr_in6 *sddr6 = (struct sockaddr_in6 *) &vcm->server_addr; - sddr6->sin6_family = AF_INET6; - inet_pton (AF_INET6, argv[optind++], &(sddr6->sin6_addr)); - sddr6->sin6_port = htons (atoi (argv[optind])); + struct in6_addr *in6 = &vcm->server_addr.v6; + inet_pton (AF_INET6, argv[optind++], in6); vcm->server_endpt.is_ip4 = 0; - vcm->server_endpt.ip = (uint8_t *) & sddr6->sin6_addr; - vcm->server_endpt.port = (uint16_t) sddr6->sin6_port; + vcm->server_endpt.ip = (uint8_t *) in6; } else { - struct sockaddr_in *saddr4 = (struct sockaddr_in *) &vcm->server_addr; - saddr4->sin_family = AF_INET; - inet_pton (AF_INET, argv[optind++], &(saddr4->sin_addr)); - saddr4->sin_port = htons (atoi (argv[optind])); + struct in_addr *in4 = &vcm->server_addr.v4; + inet_pton (AF_INET, argv[optind++], in4); vcm->server_endpt.is_ip4 = 1; - vcm->server_endpt.ip = (uint8_t *) & saddr4->sin_addr; - vcm->server_endpt.port = (uint16_t) saddr4->sin_port; + vcm->server_endpt.ip = (uint8_t *) in4; } + + if (argc == optind + 1) + vcm->server_endpt.port = htons (atoi (argv[optind])); + else + vcm->server_endpt.port = htons (VCL_TEST_SERVER_PORT); } static void @@ -944,10 +1293,14 @@ vtc_ctrl_session_exit (void) vcl_test_session_t *ctrl = &vcm->ctrl_session; int verbose = ctrl->cfg.verbose; - ctrl->cfg.test = VCL_TEST_TYPE_EXIT; + /* Only clients exits, server can accept new connections */ + if (vcm->post_test == HS_TEST_TYPE_EXIT_CLIENT) + return; + + ctrl->cfg.test = HS_TEST_TYPE_EXIT; vtinf ("(fd %d): Sending exit cfg to server...", ctrl->fd); if (verbose) - vcl_test_cfg_dump (&ctrl->cfg, 1 /* is_client */); + hs_test_cfg_dump (&ctrl->cfg, 1 /* is_client */); (void) vcl_test_write (ctrl, (uint8_t *) &ctrl->cfg, sizeof (ctrl->cfg)); sleep (1); } @@ -976,7 +1329,7 @@ vtc_ctrl_session_init (vcl_test_client_main_t *vcm, vcl_test_session_t *ctrl) ctrl->read = vcl_test_read; ctrl->write = vcl_test_write; - ctrl->cfg.cmd = VCL_TEST_CMD_SYNC; + ctrl->cfg.cmd = HS_TEST_CMD_SYNC; rv = vtc_cfg_sync (ctrl); if (rv) { @@ -984,7 +1337,7 @@ vtc_ctrl_session_init (vcl_test_client_main_t *vcm, vcl_test_session_t *ctrl) return rv; } - ctrl->cfg.ctrl_handle = ((vcl_test_cfg_t *) ctrl->rxbuf)->ctrl_handle; + ctrl->cfg.ctrl_handle = ((hs_test_cfg_t *) ctrl->rxbuf)->ctrl_handle; memset (&ctrl->stats, 0, sizeof (ctrl->stats)); return 0; @@ -1015,6 +1368,24 @@ vt_incercept_sigs (void) } } +static void +vtc_alloc_workers (vcl_test_client_main_t *vcm) +{ + vcl_test_main_t *vt = &vcl_test_main; + vtc_worker_run_fn *run_fn; + + vcm->workers = calloc (vcm->n_workers, sizeof (vcl_test_client_worker_t)); + vt->wrk = calloc (vcm->n_workers, sizeof (vcl_test_wrk_t)); + + if (vcm->ctrl_session.cfg.num_test_sessions > VCL_TEST_CFG_MAX_SELECT_SESS) + run_fn = vtc_worker_run_epoll; + else + run_fn = vtc_worker_run_select; + + for (int i = 0; i < vcm->n_workers; i++) + vcm->workers[i].wrk_run_fn = run_fn; +} + int main (int argc, char **argv) { @@ -1024,13 +1395,14 @@ main (int argc, char **argv) int rv; vcm->n_workers = 1; - vcl_test_cfg_init (&ctrl->cfg); + vcm->post_test = HS_TEST_TYPE_EXIT_CLIENT; + + hs_test_cfg_init (&ctrl->cfg); + vt_incercept_sigs (); vcl_test_session_buf_alloc (ctrl); vtc_process_opts (vcm, argc, argv); - vt_incercept_sigs (); - vcm->workers = calloc (vcm->n_workers, sizeof (vcl_test_client_worker_t)); - vt->wrk = calloc (vcm->n_workers, sizeof (vcl_test_wrk_t)); + vtc_alloc_workers (vcm); rv = vppcom_app_create ("vcl_test_client"); if (rv < 0) @@ -1038,62 +1410,67 @@ main (int argc, char **argv) /* Protos like tls/dtls/quic need init */ if (vt->protos[vcm->proto]->init) - vt->protos[vcm->proto]->init (&ctrl->cfg); + { + rv = vt->protos[vcm->proto]->init (&ctrl->cfg); + if (rv) + vtfail ("client init failed", rv); + } if ((rv = vtc_ctrl_session_init (vcm, ctrl))) vtfail ("vppcom_session_create() ctrl session", rv); /* Update ctrl port to data port */ - vcm->server_endpt.port += 1; + vcm->server_endpt.port = hs_make_data_port (vcm->server_endpt.port); - while (ctrl->cfg.test != VCL_TEST_TYPE_EXIT) + while (ctrl->cfg.test != HS_TEST_TYPE_EXIT) { if (vcm->dump_cfg) { - vcl_test_cfg_dump (&ctrl->cfg, 1 /* is_client */ ); + hs_test_cfg_dump (&ctrl->cfg, 1 /* is_client */); vcm->dump_cfg = 0; } switch (ctrl->cfg.test) { - case VCL_TEST_TYPE_ECHO: + case HS_TEST_TYPE_ECHO: vtc_echo_client (vcm); break; - case VCL_TEST_TYPE_UNI: - case VCL_TEST_TYPE_BI: + case HS_TEST_TYPE_UNI: + case HS_TEST_TYPE_BI: vtc_stream_client (vcm); break; - case VCL_TEST_TYPE_EXIT: + case HS_TEST_TYPE_EXIT: continue; - case VCL_TEST_TYPE_NONE: + case HS_TEST_TYPE_NONE: default: break; } switch (vcm->post_test) { - case VCL_TEST_TYPE_EXIT: + case HS_TEST_TYPE_EXIT: + case HS_TEST_TYPE_EXIT_CLIENT: switch (ctrl->cfg.test) { - case VCL_TEST_TYPE_EXIT: - case VCL_TEST_TYPE_UNI: - case VCL_TEST_TYPE_BI: - case VCL_TEST_TYPE_ECHO: - ctrl->cfg.test = VCL_TEST_TYPE_EXIT; + case HS_TEST_TYPE_EXIT: + case HS_TEST_TYPE_UNI: + case HS_TEST_TYPE_BI: + case HS_TEST_TYPE_ECHO: + ctrl->cfg.test = HS_TEST_TYPE_EXIT; continue; - case VCL_TEST_TYPE_NONE: + case HS_TEST_TYPE_NONE: default: break; } break; - case VCL_TEST_TYPE_NONE: - case VCL_TEST_TYPE_ECHO: - case VCL_TEST_TYPE_UNI: - case VCL_TEST_TYPE_BI: + case HS_TEST_TYPE_NONE: + case HS_TEST_TYPE_ECHO: + case HS_TEST_TYPE_UNI: + case HS_TEST_TYPE_BI: default: break; } |