1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * vsock_perf - benchmark utility for vsock. 4 * 5 * Copyright (C) 2022 SberDevices. 6 * 7 * Author: Arseniy Krasnov <AVKrasnov@sberdevices.ru> 8 */ 9 #include <getopt.h> 10 #include <stdio.h> 11 #include <stdlib.h> 12 #include <stdbool.h> 13 #include <string.h> 14 #include <errno.h> 15 #include <unistd.h> 16 #include <time.h> 17 #include <stdint.h> 18 #include <poll.h> 19 #include <sys/socket.h> 20 #include <linux/vm_sockets.h> 21 #include <sys/mman.h> 22 23 #include "msg_zerocopy_common.h" 24 25 #define DEFAULT_BUF_SIZE_BYTES (128 * 1024) 26 #define DEFAULT_TO_SEND_BYTES (64 * 1024) 27 #define DEFAULT_VSOCK_BUF_BYTES (256 * 1024) 28 #define DEFAULT_RCVLOWAT_BYTES 1 29 #define DEFAULT_PORT 1234 30 31 #define BYTES_PER_GB (1024 * 1024 * 1024ULL) 32 #define NSEC_PER_SEC (1000000000ULL) 33 34 static unsigned int port = DEFAULT_PORT; 35 static unsigned long buf_size_bytes = DEFAULT_BUF_SIZE_BYTES; 36 static unsigned long long vsock_buf_bytes = DEFAULT_VSOCK_BUF_BYTES; 37 static bool zerocopy; 38 39 static void error(const char *s) 40 { 41 perror(s); 42 exit(EXIT_FAILURE); 43 } 44 45 static time_t current_nsec(void) 46 { 47 struct timespec ts; 48 49 if (clock_gettime(CLOCK_REALTIME, &ts)) 50 error("clock_gettime"); 51 52 return (ts.tv_sec * NSEC_PER_SEC) + ts.tv_nsec; 53 } 54 55 /* From lib/cmdline.c. */ 56 static unsigned long memparse(const char *ptr) 57 { 58 char *endptr; 59 60 unsigned long long ret = strtoull(ptr, &endptr, 0); 61 62 switch (*endptr) { 63 case 'E': 64 case 'e': 65 ret <<= 10; 66 case 'P': 67 case 'p': 68 ret <<= 10; 69 case 'T': 70 case 't': 71 ret <<= 10; 72 case 'G': 73 case 'g': 74 ret <<= 10; 75 case 'M': 76 case 'm': 77 ret <<= 10; 78 case 'K': 79 case 'k': 80 ret <<= 10; 81 endptr++; 82 default: 83 break; 84 } 85 86 return ret; 87 } 88 89 static void vsock_increase_buf_size(int fd) 90 { 91 if (setsockopt(fd, AF_VSOCK, SO_VM_SOCKETS_BUFFER_MAX_SIZE, 92 &vsock_buf_bytes, sizeof(vsock_buf_bytes))) 93 error("setsockopt(SO_VM_SOCKETS_BUFFER_MAX_SIZE)"); 94 95 if (setsockopt(fd, AF_VSOCK, SO_VM_SOCKETS_BUFFER_SIZE, 96 &vsock_buf_bytes, sizeof(vsock_buf_bytes))) 97 error("setsockopt(SO_VM_SOCKETS_BUFFER_SIZE)"); 98 } 99 100 static int vsock_connect(unsigned int cid, unsigned int port) 101 { 102 union { 103 struct sockaddr sa; 104 struct sockaddr_vm svm; 105 } addr = { 106 .svm = { 107 .svm_family = AF_VSOCK, 108 .svm_port = port, 109 .svm_cid = cid, 110 }, 111 }; 112 int fd; 113 114 fd = socket(AF_VSOCK, SOCK_STREAM, 0); 115 116 if (fd < 0) { 117 perror("socket"); 118 return -1; 119 } 120 121 if (connect(fd, &addr.sa, sizeof(addr.svm)) < 0) { 122 perror("connect"); 123 close(fd); 124 return -1; 125 } 126 127 return fd; 128 } 129 130 static float get_gbps(unsigned long bits, time_t ns_delta) 131 { 132 return ((float)bits / 1000000000ULL) / 133 ((float)ns_delta / NSEC_PER_SEC); 134 } 135 136 static void run_receiver(int rcvlowat_bytes) 137 { 138 unsigned int read_cnt; 139 time_t rx_begin_ns; 140 time_t in_read_ns; 141 size_t total_recv; 142 int client_fd; 143 char *data; 144 int fd; 145 union { 146 struct sockaddr sa; 147 struct sockaddr_vm svm; 148 } addr = { 149 .svm = { 150 .svm_family = AF_VSOCK, 151 .svm_port = port, 152 .svm_cid = VMADDR_CID_ANY, 153 }, 154 }; 155 union { 156 struct sockaddr sa; 157 struct sockaddr_vm svm; 158 } clientaddr; 159 160 socklen_t clientaddr_len = sizeof(clientaddr.svm); 161 162 printf("Run as receiver\n"); 163 printf("Listen port %u\n", port); 164 printf("RX buffer %lu bytes\n", buf_size_bytes); 165 printf("vsock buffer %llu bytes\n", vsock_buf_bytes); 166 printf("SO_RCVLOWAT %d bytes\n", rcvlowat_bytes); 167 168 fd = socket(AF_VSOCK, SOCK_STREAM, 0); 169 170 if (fd < 0) 171 error("socket"); 172 173 if (bind(fd, &addr.sa, sizeof(addr.svm)) < 0) 174 error("bind"); 175 176 if (listen(fd, 1) < 0) 177 error("listen"); 178 179 client_fd = accept(fd, &clientaddr.sa, &clientaddr_len); 180 181 if (client_fd < 0) 182 error("accept"); 183 184 vsock_increase_buf_size(client_fd); 185 186 if (setsockopt(client_fd, SOL_SOCKET, SO_RCVLOWAT, 187 &rcvlowat_bytes, 188 sizeof(rcvlowat_bytes))) 189 error("setsockopt(SO_RCVLOWAT)"); 190 191 data = malloc(buf_size_bytes); 192 193 if (!data) { 194 fprintf(stderr, "'malloc()' failed\n"); 195 exit(EXIT_FAILURE); 196 } 197 198 read_cnt = 0; 199 in_read_ns = 0; 200 total_recv = 0; 201 rx_begin_ns = current_nsec(); 202 203 while (1) { 204 struct pollfd fds = { 0 }; 205 206 fds.fd = client_fd; 207 fds.events = POLLIN | POLLERR | 208 POLLHUP | POLLRDHUP; 209 210 if (poll(&fds, 1, -1) < 0) 211 error("poll"); 212 213 if (fds.revents & POLLERR) { 214 fprintf(stderr, "'poll()' error\n"); 215 exit(EXIT_FAILURE); 216 } 217 218 if (fds.revents & POLLIN) { 219 ssize_t bytes_read; 220 time_t t; 221 222 t = current_nsec(); 223 bytes_read = read(fds.fd, data, buf_size_bytes); 224 in_read_ns += (current_nsec() - t); 225 read_cnt++; 226 227 if (!bytes_read) 228 break; 229 230 if (bytes_read < 0) { 231 perror("read"); 232 exit(EXIT_FAILURE); 233 } 234 235 total_recv += bytes_read; 236 } 237 238 if (fds.revents & (POLLHUP | POLLRDHUP)) 239 break; 240 } 241 242 printf("total bytes received: %zu\n", total_recv); 243 printf("rx performance: %f Gbits/s\n", 244 get_gbps(total_recv * 8, current_nsec() - rx_begin_ns)); 245 printf("total time in 'read()': %f sec\n", (float)in_read_ns / NSEC_PER_SEC); 246 printf("average time in 'read()': %f ns\n", (float)in_read_ns / read_cnt); 247 printf("POLLIN wakeups: %i\n", read_cnt); 248 249 free(data); 250 close(client_fd); 251 close(fd); 252 } 253 254 static void enable_so_zerocopy(int fd) 255 { 256 int val = 1; 257 258 if (setsockopt(fd, SOL_SOCKET, SO_ZEROCOPY, &val, sizeof(val))) { 259 perror("setsockopt"); 260 exit(EXIT_FAILURE); 261 } 262 } 263 264 static void run_sender(int peer_cid, unsigned long to_send_bytes) 265 { 266 time_t tx_begin_ns; 267 time_t tx_total_ns; 268 size_t total_send; 269 time_t time_in_send; 270 void *data; 271 int fd; 272 273 if (zerocopy) 274 printf("Run as sender MSG_ZEROCOPY\n"); 275 else 276 printf("Run as sender\n"); 277 278 printf("Connect to %i:%u\n", peer_cid, port); 279 printf("Send %lu bytes\n", to_send_bytes); 280 printf("TX buffer %lu bytes\n", buf_size_bytes); 281 282 fd = vsock_connect(peer_cid, port); 283 284 if (fd < 0) 285 exit(EXIT_FAILURE); 286 287 if (zerocopy) { 288 enable_so_zerocopy(fd); 289 290 data = mmap(NULL, buf_size_bytes, PROT_READ | PROT_WRITE, 291 MAP_PRIVATE | MAP_ANONYMOUS, -1, 0); 292 if (data == MAP_FAILED) { 293 perror("mmap"); 294 exit(EXIT_FAILURE); 295 } 296 } else { 297 data = malloc(buf_size_bytes); 298 299 if (!data) { 300 fprintf(stderr, "'malloc()' failed\n"); 301 exit(EXIT_FAILURE); 302 } 303 } 304 305 memset(data, 0, buf_size_bytes); 306 total_send = 0; 307 time_in_send = 0; 308 tx_begin_ns = current_nsec(); 309 310 while (total_send < to_send_bytes) { 311 ssize_t sent; 312 size_t rest_bytes; 313 time_t before; 314 315 rest_bytes = to_send_bytes - total_send; 316 317 before = current_nsec(); 318 sent = send(fd, data, (rest_bytes > buf_size_bytes) ? 319 buf_size_bytes : rest_bytes, 320 zerocopy ? MSG_ZEROCOPY : 0); 321 time_in_send += (current_nsec() - before); 322 323 if (sent <= 0) 324 error("write"); 325 326 total_send += sent; 327 328 if (zerocopy) { 329 struct pollfd fds = { 0 }; 330 331 fds.fd = fd; 332 333 if (poll(&fds, 1, -1) < 0) { 334 perror("poll"); 335 exit(EXIT_FAILURE); 336 } 337 338 if (!(fds.revents & POLLERR)) { 339 fprintf(stderr, "POLLERR expected\n"); 340 exit(EXIT_FAILURE); 341 } 342 343 vsock_recv_completion(fd, NULL); 344 } 345 } 346 347 tx_total_ns = current_nsec() - tx_begin_ns; 348 349 printf("total bytes sent: %zu\n", total_send); 350 printf("tx performance: %f Gbits/s\n", 351 get_gbps(total_send * 8, time_in_send)); 352 printf("total time in tx loop: %f sec\n", 353 (float)tx_total_ns / NSEC_PER_SEC); 354 printf("time in 'send()': %f sec\n", 355 (float)time_in_send / NSEC_PER_SEC); 356 357 close(fd); 358 359 if (zerocopy) 360 munmap(data, buf_size_bytes); 361 else 362 free(data); 363 } 364 365 static const char optstring[] = ""; 366 static const struct option longopts[] = { 367 { 368 .name = "help", 369 .has_arg = no_argument, 370 .val = 'H', 371 }, 372 { 373 .name = "sender", 374 .has_arg = required_argument, 375 .val = 'S', 376 }, 377 { 378 .name = "port", 379 .has_arg = required_argument, 380 .val = 'P', 381 }, 382 { 383 .name = "bytes", 384 .has_arg = required_argument, 385 .val = 'M', 386 }, 387 { 388 .name = "buf-size", 389 .has_arg = required_argument, 390 .val = 'B', 391 }, 392 { 393 .name = "vsk-size", 394 .has_arg = required_argument, 395 .val = 'V', 396 }, 397 { 398 .name = "rcvlowat", 399 .has_arg = required_argument, 400 .val = 'R', 401 }, 402 { 403 .name = "zerocopy", 404 .has_arg = no_argument, 405 .val = 'Z', 406 }, 407 {}, 408 }; 409 410 static void usage(void) 411 { 412 printf("Usage: ./vsock_perf [--help] [options]\n" 413 "\n" 414 "This is benchmarking utility, to test vsock performance.\n" 415 "It runs in two modes: sender or receiver. In sender mode, it\n" 416 "connects to the specified CID and starts data transmission.\n" 417 "\n" 418 "Options:\n" 419 " --help This message\n" 420 " --sender <cid> Sender mode (receiver default)\n" 421 " <cid> of the receiver to connect to\n" 422 " --zerocopy Enable zerocopy (for sender mode only)\n" 423 " --port <port> Port (default %d)\n" 424 " --bytes <bytes>KMG Bytes to send (default %d)\n" 425 " --buf-size <bytes>KMG Data buffer size (default %d). In sender mode\n" 426 " it is the buffer size, passed to 'write()'. In\n" 427 " receiver mode it is the buffer size passed to 'read()'.\n" 428 " --vsk-size <bytes>KMG Socket buffer size (default %d)\n" 429 " --rcvlowat <bytes>KMG SO_RCVLOWAT value (default %d)\n" 430 "\n", DEFAULT_PORT, DEFAULT_TO_SEND_BYTES, 431 DEFAULT_BUF_SIZE_BYTES, DEFAULT_VSOCK_BUF_BYTES, 432 DEFAULT_RCVLOWAT_BYTES); 433 exit(EXIT_FAILURE); 434 } 435 436 static long strtolx(const char *arg) 437 { 438 long value; 439 char *end; 440 441 value = strtol(arg, &end, 10); 442 443 if (end != arg + strlen(arg)) 444 usage(); 445 446 return value; 447 } 448 449 int main(int argc, char **argv) 450 { 451 unsigned long to_send_bytes = DEFAULT_TO_SEND_BYTES; 452 int rcvlowat_bytes = DEFAULT_RCVLOWAT_BYTES; 453 int peer_cid = -1; 454 bool sender = false; 455 456 while (1) { 457 int opt = getopt_long(argc, argv, optstring, longopts, NULL); 458 459 if (opt == -1) 460 break; 461 462 switch (opt) { 463 case 'V': /* Peer buffer size. */ 464 vsock_buf_bytes = memparse(optarg); 465 break; 466 case 'R': /* SO_RCVLOWAT value. */ 467 rcvlowat_bytes = memparse(optarg); 468 break; 469 case 'P': /* Port to connect to. */ 470 port = strtolx(optarg); 471 break; 472 case 'M': /* Bytes to send. */ 473 to_send_bytes = memparse(optarg); 474 break; 475 case 'B': /* Size of rx/tx buffer. */ 476 buf_size_bytes = memparse(optarg); 477 break; 478 case 'S': /* Sender mode. CID to connect to. */ 479 peer_cid = strtolx(optarg); 480 sender = true; 481 break; 482 case 'H': /* Help. */ 483 usage(); 484 break; 485 case 'Z': /* Zerocopy. */ 486 zerocopy = true; 487 break; 488 default: 489 usage(); 490 } 491 } 492 493 if (!sender) 494 run_receiver(rcvlowat_bytes); 495 else 496 run_sender(peer_cid, to_send_bytes); 497 498 return 0; 499 } 500