/*---------------------------------------------------------------------------*/
static void process_response(struct test_params *test_params,
struct xio_msg *rsp)
{
struct xio_iovec_ex *isglist = vmsg_sglist(&rsp->in);
int inents = vmsg_sglist_nents(&rsp->in);
if (test_params->stat.first_time) {
struct xio_iovec_ex *osglist = vmsg_sglist(&rsp->out);
int onents = vmsg_sglist_nents(&rsp->out);
size_t data_len = 0;
int i;
for (i = 0; i < onents; i++)
data_len += osglist[i].iov_len;
test_params->stat.txlen = rsp->out.header.iov_len + data_len;
data_len = 0;
for (i = 0; i < inents; i++)
data_len += isglist[i].iov_len;
test_params->stat.rxlen = rsp->in.header.iov_len + data_len;
test_params->stat.start_time = get_cpu_usecs();
test_params->stat.first_time = 0;
data_len = test_params->stat.txlen > test_params->stat.rxlen ?
test_params->stat.txlen : test_params->stat.rxlen;
data_len = data_len/1024;
test_params->stat.print_counter = (data_len ?
PRINT_COUNTER/data_len : PRINT_COUNTER);
if (test_params->stat.print_counter < 1000)
test_params->stat.print_counter = 1000;
test_params->disconnect_nr =
test_params->stat.print_counter * DISCONNECT_FACTOR;
}
if (++test_params->stat.cnt == test_params->stat.print_counter) {
char timeb[40];
uint64_t delta = get_cpu_usecs() - test_params->stat.start_time;
uint64_t pps = (test_params->stat.cnt*USECS_IN_SEC)/delta;
double txbw = (1.0*pps*test_params->stat.txlen/ONE_MB);
double rxbw = (1.0*pps*test_params->stat.rxlen/ONE_MB);
printf("transactions per second: %lu, bandwidth: " \
"TX %.2f MB/s, RX: %.2f MB/s, length: TX: %zd B, RX: %zd B\n",
pps, txbw, rxbw,
test_params->stat.txlen, test_params->stat.rxlen);
get_time(timeb, 40);
printf("**** [%s] - message [%zd] %s - %s\n",
timeb, (rsp->request->sn + 1),
(char *)rsp->in.header.iov_base,
(char *)(inents > 0 ? isglist[0].iov_base : NULL));
test_params->stat.cnt = 0;
test_params->stat.start_time = get_cpu_usecs();
}
}
static int server_on_request(struct xio_session *session,
struct xio_msg *xio_req,
int last_in_rxq,
void *cb_user_conext)
{
struct client_info *ci = (struct client_info *)cb_user_conext;
struct sd_req *hdr;
struct request *req;
struct xio_iovec_ex *sglist = vmsg_sglist(&xio_req->in);
int nents = vmsg_sglist_nents(&xio_req->in);
sd_debug("on request: %p, %p, nents: %d", session, xio_req, nents);
hdr = xio_req->in.header.iov_base;
req = alloc_request(ci, hdr->data_length);
memcpy(&req->rq, hdr, sizeof(req->rq));
if (hdr->data_length && hdr->flags & SD_FLAG_CMD_WRITE) {
sd_assert(nents == 1);
req->data = sglist[0].iov_base;
}
xio_req->in.header.iov_base = NULL;
xio_req->in.header.iov_len = 0;
vmsg_sglist_set_nents(&xio_req->in, 0);
ci->xio_req = xio_req;
queue_request(req);
xio_context_stop_loop(xio_get_main_ctx());
return 0;
}
static int gw_client_on_response(struct xio_session *session,
struct xio_msg *rsp,
int last_in_rxq,
void *cb_user_context)
{
struct xio_forward_info_entry *fi_entry =
(struct xio_forward_info_entry *)cb_user_context;
struct xio_forward_info *fi = fi_entry->fi;
struct xio_vmsg *pimsg = &rsp->in;
struct xio_iovec_ex *isglist = vmsg_sglist(pimsg);
int nents = vmsg_sglist_nents(pimsg), total = 0;
sd_debug("response on fi_entry %p", fi_entry);
for (int i = 0; i < nents; i++) {
memcpy((char *)fi_entry->buf + total,
isglist[i].iov_base, isglist[i].iov_len);
total += isglist[i].iov_len;
}
fi->nr_done++;
if (fi->nr_done == fi->nr_send)
xio_context_stop_loop(fi->ctx);
return 0;
}
/*---------------------------------------------------------------------------*/
static void process_response(struct session_data *session_data,
struct xio_msg *rsp)
{
if (++session_data->cnt == PRINT_COUNTER) {
struct xio_iovec_ex *isglist = vmsg_sglist(&rsp->in);
int inents = vmsg_sglist_nents(&rsp->in);
printf("message: [%lu] - %s\n",
(rsp->request->sn + 1),
(char *)rsp->in.header.iov_base);
printf("message: [%lu] - %s\n",
(rsp->request->sn + 1),
(char *)(inents > 0 ? isglist[0].iov_base : NULL));
session_data->cnt = 0;
}
}
/*---------------------------------------------------------------------------*/
static void process_tx_message(struct ow_test_params *ow_params,
struct xio_msg *msg)
{
struct xio_iovec_ex *osglist = vmsg_sglist(&msg->out);
int onents = vmsg_sglist_nents(&msg->out);
if (ow_params->tx_stat.first_time) {
size_t data_len = 0;
int i;
for (i = 0; i < onents; i++)
data_len += osglist[i].iov_len;
ow_params->tx_stat.xlen = msg->out.header.iov_len + data_len;
ow_params->tx_stat.start_time = get_cpu_usecs();
ow_params->tx_stat.first_time = 0;
data_len = ow_params->tx_stat.xlen/1024;
ow_params->tx_stat.print_counter = data_len ?
PRINT_COUNTER/data_len : PRINT_COUNTER;
if (ow_params->tx_stat.print_counter < 1000)
ow_params->tx_stat.print_counter = 1000;
ow_params->disconnect_nr =
ow_params->tx_stat.print_counter * DISCONNECT_FACTOR;
}
if (++ow_params->tx_stat.cnt == ow_params->tx_stat.print_counter) {
char timeb[40];
uint64_t delta =
get_cpu_usecs() - ow_params->tx_stat.start_time;
uint64_t pps = (ow_params->tx_stat.cnt*USECS_IN_SEC)/delta;
double txbw = (1.0*pps*ow_params->tx_stat.xlen/ONE_MB);
printf("transactions per second: %lu, bandwidth: " \
"TX %.2f MB/s,length: TX: %zd B\n",
pps, txbw, ow_params->tx_stat.xlen);
get_time(timeb, 40);
printf("**** [%s] - message [%lu] %s - %s\n",
timeb, (msg->sn + 1),
(char *)msg->out.header.iov_base,
(char *)(onents > 0 ? osglist[0].iov_base : NULL));
ow_params->tx_stat.cnt = 0;
ow_params->tx_stat.start_time = get_cpu_usecs();
}
}
/*---------------------------------------------------------------------------*/
static int assign_data_in_buf(struct xio_msg *msg, void *cb_user_context)
{
struct test_params *test_params = (struct test_params *)cb_user_context;
struct xio_iovec_ex *sglist = vmsg_sglist(&msg->in);
int nents = vmsg_sglist_nents(&msg->in);
int i;
if (test_params->reg_mem.addr == NULL)
xio_mem_alloc(XIO_READ_BUF_LEN, &test_params->reg_mem);
for (i = 0; i < nents; i++) {
sglist[i].iov_base = test_params->reg_mem.addr;
sglist[i].mr = test_params->reg_mem.mr;
}
return 0;
}
/*---------------------------------------------------------------------------*/
static void process_request(struct server_data *server_data,
struct xio_msg *req)
{
struct xio_iovec_ex *sglist = vmsg_sglist(&req->in);
char *str;
int nents = vmsg_sglist_nents(&req->in);
int len, i;
char tmp;
/* note all data is packed together so in order to print each
* part on its own NULL character is temporarily stuffed
* before the print and the original character is restored after
* the printf
*/
if (++server_data->cnt == PRINT_COUNTER) {
str = (char *)req->in.header.iov_base;
len = req->in.header.iov_len;
if (str) {
if (((unsigned) len) > 64)
len = 64;
tmp = str[len];
str[len] = '\0';
logit(LOG_INFO, "message header : [%lu] - %s",
(req->sn + 1), str);
str[len] = tmp;
}
for (i = 0; i < nents; i++) {
str = (char *)sglist[i].iov_base;
len = sglist[i].iov_len;
if (str) {
if (((unsigned)len) > 64)
len = 64;
tmp = str[len];
str[len] = '\0';
logit(LOG_INFO, "message data: " \
"[%lu][%d][%d] - %s",
(req->sn + 1), i, len, str);
str[len] = tmp;
}
}
server_data->cnt = 0;
}
req->in.header.iov_base = NULL;
req->in.header.iov_len = 0;
vmsg_sglist_set_nents(&req->in, 0);
}
static void msg_finalize(struct sd_req *hdr, void *data, struct xio_msg *xrsp)
{
struct xio_vmsg *pimsg = &xrsp->in;
struct xio_iovec_ex *isglist = vmsg_sglist(pimsg);
int nents = vmsg_sglist_nents(pimsg);
sd_assert(xrsp->in.header.iov_len == sizeof(struct sd_rsp));
memcpy(hdr, xrsp->in.header.iov_base, sizeof(*hdr));
if (data) {
int total = 0;
for (int i = 0; i < nents; i++) {
memcpy((char *)data + total, isglist[i].iov_base,
isglist[i].iov_len);
total += isglist[i].iov_len;
}
}
xio_release_response(xrsp);
}
/*---------------------------------------------------------------------------*/
static void process_message(struct test_params *test_params,
struct xio_msg *msg)
{
struct xio_iovec_ex *osglist = vmsg_sglist(&msg->out);
int onents = vmsg_sglist_nents(&msg->out);
if (test_params->stat.first_time) {
size_t data_len = 0;
int i;
for (i = 0; i < onents; i++)
data_len += osglist[i].iov_len;
test_params->stat.txlen = msg->out.header.iov_len + data_len;
test_params->stat.start_time = get_cpu_usecs();
test_params->stat.first_time = 0;
data_len = test_params->stat.txlen/1024;
test_params->stat.print_counter = (data_len ?
PRINT_COUNTER/data_len : PRINT_COUNTER);
if (test_params->stat.print_counter < 1000)
test_params->stat.print_counter = 1000;
test_params->disconnect_nr =
test_params->stat.print_counter * DISCONNECT_FACTOR;
}
if (++test_params->stat.cnt == test_params->stat.print_counter) {
uint64_t delta = get_cpu_usecs() - test_params->stat.start_time;
uint64_t pps = (test_params->stat.cnt*USECS_IN_SEC)/delta;
double txbw = (1.0*pps*test_params->stat.txlen/ONE_MB);
printf("transactions per second: %lu, bandwidth: " \
"TX %.2f MB/s, length: TX: %zd B\n",
pps, txbw,
test_params->stat.txlen);
test_params->stat.cnt = 0;
test_params->stat.start_time = get_cpu_usecs();
}
}
