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 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(unsigned long 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 %lu bytes\n", vsock_buf_bytes); 166 printf("SO_RCVLOWAT %lu 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 run_sender(int peer_cid, unsigned long to_send_bytes) 255 { 256 time_t tx_begin_ns; 257 time_t tx_total_ns; 258 size_t total_send; 259 time_t time_in_send; 260 void *data; 261 int fd; 262 263 if (zerocopy) 264 printf("Run as sender MSG_ZEROCOPY\n"); 265 else 266 printf("Run as sender\n"); 267 268 printf("Connect to %i:%u\n", peer_cid, port); 269 printf("Send %lu bytes\n", to_send_bytes); 270 printf("TX buffer %lu bytes\n", buf_size_bytes); 271 272 fd = vsock_connect(peer_cid, port); 273 274 if (fd < 0) 275 exit(EXIT_FAILURE); 276 277 if (zerocopy) { 278 enable_so_zerocopy(fd); 279 280 data = mmap(NULL, buf_size_bytes, PROT_READ | PROT_WRITE, 281 MAP_PRIVATE | MAP_ANONYMOUS, -1, 0); 282 if (data == MAP_FAILED) { 283 perror("mmap"); 284 exit(EXIT_FAILURE); 285 } 286 } else { 287 data = malloc(buf_size_bytes); 288 289 if (!data) { 290 fprintf(stderr, "'malloc()' failed\n"); 291 exit(EXIT_FAILURE); 292 } 293 } 294 295 memset(data, 0, buf_size_bytes); 296 total_send = 0; 297 time_in_send = 0; 298 tx_begin_ns = current_nsec(); 299 300 while (total_send < to_send_bytes) { 301 ssize_t sent; 302 size_t rest_bytes; 303 time_t before; 304 305 rest_bytes = to_send_bytes - total_send; 306 307 before = current_nsec(); 308 sent = send(fd, data, (rest_bytes > buf_size_bytes) ? 309 buf_size_bytes : rest_bytes, 310 zerocopy ? MSG_ZEROCOPY : 0); 311 time_in_send += (current_nsec() - before); 312 313 if (sent <= 0) 314 error("write"); 315 316 total_send += sent; 317 318 if (zerocopy) { 319 struct pollfd fds = { 0 }; 320 321 fds.fd = fd; 322 323 if (poll(&fds, 1, -1) < 0) { 324 perror("poll"); 325 exit(EXIT_FAILURE); 326 } 327 328 if (!(fds.revents & POLLERR)) { 329 fprintf(stderr, "POLLERR expected\n"); 330 exit(EXIT_FAILURE); 331 } 332 333 vsock_recv_completion(fd, NULL); 334 } 335 } 336 337 tx_total_ns = current_nsec() - tx_begin_ns; 338 339 printf("total bytes sent: %zu\n", total_send); 340 printf("tx performance: %f Gbits/s\n", 341 get_gbps(total_send * 8, time_in_send)); 342 printf("total time in tx loop: %f sec\n", 343 (float)tx_total_ns / NSEC_PER_SEC); 344 printf("time in 'send()': %f sec\n", 345 (float)time_in_send / NSEC_PER_SEC); 346 347 close(fd); 348 349 if (zerocopy) 350 munmap(data, buf_size_bytes); 351 else 352 free(data); 353 } 354 355 static const char optstring[] = ""; 356 static const struct option longopts[] = { 357 { 358 .name = "help", 359 .has_arg = no_argument, 360 .val = 'H', 361 }, 362 { 363 .name = "sender", 364 .has_arg = required_argument, 365 .val = 'S', 366 }, 367 { 368 .name = "port", 369 .has_arg = required_argument, 370 .val = 'P', 371 }, 372 { 373 .name = "bytes", 374 .has_arg = required_argument, 375 .val = 'M', 376 }, 377 { 378 .name = "buf-size", 379 .has_arg = required_argument, 380 .val = 'B', 381 }, 382 { 383 .name = "vsk-size", 384 .has_arg = required_argument, 385 .val = 'V', 386 }, 387 { 388 .name = "rcvlowat", 389 .has_arg = required_argument, 390 .val = 'R', 391 }, 392 { 393 .name = "zerocopy", 394 .has_arg = no_argument, 395 .val = 'Z', 396 }, 397 {}, 398 }; 399 400 static void usage(void) 401 { 402 printf("Usage: ./vsock_perf [--help] [options]\n" 403 "\n" 404 "This is benchmarking utility, to test vsock performance.\n" 405 "It runs in two modes: sender or receiver. In sender mode, it\n" 406 "connects to the specified CID and starts data transmission.\n" 407 "\n" 408 "Options:\n" 409 " --help This message\n" 410 " --sender <cid> Sender mode (receiver default)\n" 411 " <cid> of the receiver to connect to\n" 412 " --zerocopy Enable zerocopy (for sender mode only)\n" 413 " --port <port> Port (default %d)\n" 414 " --bytes <bytes>KMG Bytes to send (default %d)\n" 415 " --buf-size <bytes>KMG Data buffer size (default %d). In sender mode\n" 416 " it is the buffer size, passed to 'write()'. In\n" 417 " receiver mode it is the buffer size passed to 'read()'.\n" 418 " --vsk-size <bytes>KMG Socket buffer size (default %d)\n" 419 " --rcvlowat <bytes>KMG SO_RCVLOWAT value (default %d)\n" 420 "\n", DEFAULT_PORT, DEFAULT_TO_SEND_BYTES, 421 DEFAULT_BUF_SIZE_BYTES, DEFAULT_VSOCK_BUF_BYTES, 422 DEFAULT_RCVLOWAT_BYTES); 423 exit(EXIT_FAILURE); 424 } 425 426 static long strtolx(const char *arg) 427 { 428 long value; 429 char *end; 430 431 value = strtol(arg, &end, 10); 432 433 if (end != arg + strlen(arg)) 434 usage(); 435 436 return value; 437 } 438 439 int main(int argc, char **argv) 440 { 441 unsigned long to_send_bytes = DEFAULT_TO_SEND_BYTES; 442 unsigned long rcvlowat_bytes = DEFAULT_RCVLOWAT_BYTES; 443 int peer_cid = -1; 444 bool sender = false; 445 446 while (1) { 447 int opt = getopt_long(argc, argv, optstring, longopts, NULL); 448 449 if (opt == -1) 450 break; 451 452 switch (opt) { 453 case 'V': /* Peer buffer size. */ 454 vsock_buf_bytes = memparse(optarg); 455 break; 456 case 'R': /* SO_RCVLOWAT value. */ 457 rcvlowat_bytes = memparse(optarg); 458 break; 459 case 'P': /* Port to connect to. */ 460 port = strtolx(optarg); 461 break; 462 case 'M': /* Bytes to send. */ 463 to_send_bytes = memparse(optarg); 464 break; 465 case 'B': /* Size of rx/tx buffer. */ 466 buf_size_bytes = memparse(optarg); 467 break; 468 case 'S': /* Sender mode. CID to connect to. */ 469 peer_cid = strtolx(optarg); 470 sender = true; 471 break; 472 case 'H': /* Help. */ 473 usage(); 474 break; 475 case 'Z': /* Zerocopy. */ 476 zerocopy = true; 477 break; 478 default: 479 usage(); 480 } 481 } 482 483 if (!sender) 484 run_receiver(rcvlowat_bytes); 485 else 486 run_sender(peer_cid, to_send_bytes); 487 488 return 0; 489 } 490