From patchwork Fri Nov 25 17:15:08 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Arseniy Krasnov X-Patchwork-Id: 26108 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:adf:f944:0:0:0:0:0 with SMTP id q4csp4172804wrr; Fri, 25 Nov 2022 09:16:42 -0800 (PST) X-Google-Smtp-Source: AA0mqf74+pFpaY2vTMwdUCYueLEUG8t6gjomyEXZlEGU03whfhvMcYIipjRjGTpuB5/rJJyd1IdD X-Received: by 2002:a63:f91a:0:b0:477:8109:ccea with SMTP id h26-20020a63f91a000000b004778109cceamr20286015pgi.376.1669396602391; Fri, 25 Nov 2022 09:16:42 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1669396602; cv=none; d=google.com; s=arc-20160816; b=iK7EjDLb/ts+Km0/vv+usVWQjvN+KME/oYQlLu3sTdO4r1J7T1l26pwRxdEhye8Rtu sY0iXultil+8MnJMzl34A2IF2mIiZBxmSA2EI1ZUJJ7C7RnAj+S9oCJEoenR2N7nInxi MB/4/UpapJ87Hd8Z+iHKzHfu0uiDOtS2jjOiHVnNSqtvoWUzAh67NQFHymJ43F8YY09K ucV2hoy8tyhej4OdQWN3LLmiiYDBHx18lWeg+9t09Beq+2UJw0yXp8XP7yj/h3Wrojm9 TtzCtPw7ajj5QUZlfhEC5/vhnsaRrKWeXvovmq94L4RuRo5MM6sT0xBBSOrYEUZtSHR0 uAqQ== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:mime-version:content-transfer-encoding :content-id:content-language:accept-language:in-reply-to:message-id :date:thread-index:thread-topic:subject:cc:to:from:dkim-signature; bh=ql77uGu/Palxfhx5tOIxZcAYn3XCSN8xPcKIUYuh8t8=; b=ebUhgbEB4V2k9WBnsQI08XDEtD3g1boO+pqhukH76zWlbqZlAymbQrhdHObr1bUHlI 1e99IDkl+JgUrBp/BBRIiYUps7pGczMmIw2SexqKVHhKMzk39KkS6WDJwPuG2pmTzgAr 3Hc8lpTyQ04Loed5gyZDX3UVhELfsFndkohFaiMcQqMkJyYgnNMZimwbQNV/IqjRwKCL QDw7UJRPX/qHa/ziDgAINwA3o84l3GsgFffFgCmzCR2r2f46FfmrFQM5tzYw9vcnpqpU jnzlwnrWzRmEjE6SDO1LHNPxHTfWNQompqEtr+SLVkY63S7E5YV+lLr43xRpNRt+ckTa 6ZWA== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@sberdevices.ru header.s=mail header.b=FDBiDEeO; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=QUARANTINE sp=QUARANTINE dis=NONE) header.from=sberdevices.ru Received: from out1.vger.email (out1.vger.email. [2620:137:e000::1:20]) by mx.google.com with ESMTP id c7-20020a656187000000b0043aebb63fc9si4475707pgv.732.2022.11.25.09.16.29; Fri, 25 Nov 2022 09:16:42 -0800 (PST) Received-SPF: pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) client-ip=2620:137:e000::1:20; Authentication-Results: mx.google.com; dkim=pass header.i=@sberdevices.ru header.s=mail header.b=FDBiDEeO; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=QUARANTINE sp=QUARANTINE dis=NONE) header.from=sberdevices.ru Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S230026AbiKYRPP (ORCPT + 99 others); Fri, 25 Nov 2022 12:15:15 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:52368 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S229487AbiKYRPM (ORCPT ); Fri, 25 Nov 2022 12:15:12 -0500 Received: from mx.sberdevices.ru (mx.sberdevices.ru [45.89.227.171]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id E702651325; Fri, 25 Nov 2022 09:15:10 -0800 (PST) Received: from s-lin-edge02.sberdevices.ru (localhost [127.0.0.1]) by mx.sberdevices.ru (Postfix) with ESMTP id 418EA5FD0B; Fri, 25 Nov 2022 20:15:09 +0300 (MSK) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=sberdevices.ru; s=mail; t=1669396509; bh=ql77uGu/Palxfhx5tOIxZcAYn3XCSN8xPcKIUYuh8t8=; h=From:To:Subject:Date:Message-ID:Content-Type:MIME-Version; b=FDBiDEeOS2k6hDA1qGlNX/3DzsK8GoWCLEst8zAU5Krmzwg0kabLhIU7CYaIgugZM uow4bkx6KB4iQmhrTUS2Uwp4aEWipuLNMnw2Q+CyEEbxiVI+7R3EqAhlpwc2p47/6k jjrzisgIXUghk7rvpDZ4UaFLfhPZWFvjerWzY66Bt0PJkZiw9cGTGtjNF2ldb4o0Ql jGX4pCa55Xb66sWfxdwCXR/5HQUV0IRCPhzeJYRhMWZdkPpXTuQ8e7ttf92hwjT7U8 rvSD5sclqD3o2sNqX0NHVrrm7brcip/OObd+zXkHXDipI8jM+8LQVwzHMPpmUPb0h4 cKyGmbTVmf+4w== Received: from S-MS-EXCH01.sberdevices.ru (S-MS-EXCH01.sberdevices.ru [172.16.1.4]) by mx.sberdevices.ru (Postfix) with ESMTP; Fri, 25 Nov 2022 20:15:08 +0300 (MSK) From: Arseniy Krasnov To: Stefano Garzarella , "David S. Miller" , "edumazet@google.com" , "Jakub Kicinski" , Paolo Abeni , "kys@microsoft.com" , "haiyangz@microsoft.com" , "wei.liu@kernel.org" , "Dexuan Cui" , Bryan Tan , Vishnu Dasa , Arseniy Krasnov , "Krasnov Arseniy" , Bobby Eshleman , Bobby Eshleman CC: "linux-kernel@vger.kernel.org" , "netdev@vger.kernel.org" , "virtualization@lists.linux-foundation.org" , "linux-hyperv@vger.kernel.org" , kernel Subject: [RFC PATCH v2 6/6] test/vsock: vsock_perf utility Thread-Topic: [RFC PATCH v2 6/6] test/vsock: vsock_perf utility Thread-Index: AQHZAPF3e7KytiwPOk+Ft+TrN7czrQ== Date: Fri, 25 Nov 2022 17:15:08 +0000 Message-ID: <93a19249-e3f3-c1f8-c58a-0f549b94f1b5@sberdevices.ru> In-Reply-To: <9d96f6c6-1d4f-8197-b3bc-8957124c8933@sberdevices.ru> Accept-Language: en-US, ru-RU Content-Language: en-US X-MS-Has-Attach: X-MS-TNEF-Correlator: x-originating-ip: [172.16.1.12] Content-ID: MIME-Version: 1.0 X-KSMG-Rule-ID: 4 X-KSMG-Message-Action: clean X-KSMG-AntiSpam-Status: not scanned, disabled by settings X-KSMG-AntiSpam-Interceptor-Info: not scanned X-KSMG-AntiPhishing: not scanned, disabled by settings X-KSMG-AntiVirus: Kaspersky Secure Mail Gateway, version 1.1.2.30, bases: 2022/11/25 14:59:00 #20610704 X-KSMG-AntiVirus-Status: Clean, skipped X-Spam-Status: No, score=-2.1 required=5.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,SPF_HELO_NONE,SPF_PASS autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on lindbergh.monkeyblade.net Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org X-getmail-retrieved-from-mailbox: =?utf-8?q?INBOX?= X-GMAIL-THRID: =?utf-8?q?1750489212035427854?= X-GMAIL-MSGID: =?utf-8?q?1750489212035427854?= This adds utility to check vsock rx/tx performance. Usage as sender: ./vsock_perf -p -m -p -r Signed-off-by: Arseniy Krasnov --- tools/testing/vsock/Makefile | 1 + tools/testing/vsock/README | 34 +++ tools/testing/vsock/vsock_perf.c | 400 +++++++++++++++++++++++++++++++ 3 files changed, 435 insertions(+) create mode 100644 tools/testing/vsock/vsock_perf.c -- 2.25.1 diff --git a/tools/testing/vsock/Makefile b/tools/testing/vsock/Makefile index f8293c6910c9..d36fdd59fe2e 100644 --- a/tools/testing/vsock/Makefile +++ b/tools/testing/vsock/Makefile @@ -3,6 +3,7 @@ all: test test: vsock_test vsock_diag_test vsock_test: vsock_test.o timeout.o control.o util.o vsock_diag_test: vsock_diag_test.o timeout.o control.o util.o +vsock_perf: vsock_perf.o CFLAGS += -g -O2 -Werror -Wall -I. -I../../include -I../../../usr/include -Wno-pointer-sign -fno-strict-overflow -fno-strict-aliasing -fno-common -MMD -U_FORTIFY_SOURCE -D_GNU_SOURCE .PHONY: all test clean diff --git a/tools/testing/vsock/README b/tools/testing/vsock/README index 4d5045e7d2c3..dbeba1d62016 100644 --- a/tools/testing/vsock/README +++ b/tools/testing/vsock/README @@ -35,3 +35,37 @@ Invoke test binaries in both directions as follows: --control-port=$GUEST_IP \ --control-port=1234 \ --peer-cid=3 + +vsock_perf utility +------------------- +'vsock_perf' is simple tool to measure vsock performance. It works in +sender/receiver modes: sender waits for connection at specified port, +and after accept, starts data transmission to receiver. After data +processing is done, it prints several metrics(see below). + +Usage: +# run as sender +# listen port 1234, tx buffer size is 1MB, send of data 1G +./vsock_perf -s -p 1234 -b 1MB -m 1G + +Output: +tx performance: A Gb/s + +Output explanation: +A is calculated as "number of bytes to send" / "time in tx loop" + +# run as receiver +# connect to CID 2, port 1234, rx buffer size is 1MB, peer buf is 1G, SO_RCVLOWAT is 65536 +./vsock_perf -c 2 -p 1234 -b 1MB -v 1G -r 65536 + +Output: +rx performance: A Gb/s +total in 'read()': B sec +POLLIN wakeups: C +average in 'read()': D ns + +Output explanation: +A is calculated as "number of received bytes" / "time in rx loop". +B is time, spent in 'read()' system call(excluding 'poll()') +C is number of 'poll()' wake ups with POLLIN bit set. +D is B / C, e.g. average amount of time, spent in single 'read()'. diff --git a/tools/testing/vsock/vsock_perf.c b/tools/testing/vsock/vsock_perf.c new file mode 100644 index 000000000000..bca2027de52d --- /dev/null +++ b/tools/testing/vsock/vsock_perf.c @@ -0,0 +1,400 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * vsock_perf - benchmark utility for vsock. + * + * Copyright (C) 2022 SberDevices. + * + * Author: Arseniy Krasnov + */ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define DEFAULT_BUF_SIZE_BYTES (128 * 1024) +#define DEFAULT_TO_SEND_BYTES (64 * 1024) +#define DEFAULT_VSOCK_BUF_BYTES (256 * 1024) +#define DEFAULT_RCVLOWAT_BYTES 1 +#define DEFAULT_PORT 1234 +#define DEFAULT_CID 2 + +#define BYTES_PER_GB (1024 * 1024 * 1024ULL) +#define NSEC_PER_SEC (1000000000ULL) + +static unsigned int port = DEFAULT_PORT; +static unsigned long buf_size_bytes = DEFAULT_BUF_SIZE_BYTES; +static unsigned long vsock_buf_bytes = DEFAULT_VSOCK_BUF_BYTES; + +static inline time_t current_nsec(void) +{ + struct timespec ts; + + if (clock_gettime(CLOCK_REALTIME, &ts)) { + perror("clock_gettime"); + exit(EXIT_FAILURE); + } + + return (ts.tv_sec * NSEC_PER_SEC) + ts.tv_nsec; +} + +/* From lib/cmdline.c. */ +static unsigned long memparse(const char *ptr) +{ + char *endptr; + + unsigned long long ret = strtoull(ptr, &endptr, 0); + + switch (*endptr) { + case 'E': + case 'e': + ret <<= 10; + case 'P': + case 'p': + ret <<= 10; + case 'T': + case 't': + ret <<= 10; + case 'G': + case 'g': + ret <<= 10; + case 'M': + case 'm': + ret <<= 10; + case 'K': + case 'k': + ret <<= 10; + endptr++; + default: + break; + } + + return ret; +} + +static void vsock_increase_buf_size(int fd) +{ + if (setsockopt(fd, AF_VSOCK, SO_VM_SOCKETS_BUFFER_MAX_SIZE, + &vsock_buf_bytes, sizeof(vsock_buf_bytes))) { + perror("setsockopt"); + exit(EXIT_FAILURE); + } + + if (setsockopt(fd, AF_VSOCK, SO_VM_SOCKETS_BUFFER_SIZE, + &vsock_buf_bytes, sizeof(vsock_buf_bytes))) { + perror("setsockopt"); + exit(EXIT_FAILURE); + } +} + +static int vsock_connect(unsigned int cid, unsigned int port) +{ + union { + struct sockaddr sa; + struct sockaddr_vm svm; + } addr = { + .svm = { + .svm_family = AF_VSOCK, + .svm_port = port, + .svm_cid = cid, + }, + }; + int fd; + + fd = socket(AF_VSOCK, SOCK_STREAM, 0); + + if (fd < 0) + return -1; + + vsock_increase_buf_size(fd); + + if (connect(fd, &addr.sa, sizeof(addr.svm)) < 0) { + close(fd); + return -1; + } + + return fd; +} + +static float get_gbps(unsigned long bytes, time_t ns_delta) +{ + return ((float)bytes / BYTES_PER_GB) / + ((float)ns_delta / NSEC_PER_SEC); +} + +static void run_sender(unsigned long to_send_bytes) +{ + time_t tx_begin_ns; + size_t total_send; + int client_fd; + char *data; + int fd; + union { + struct sockaddr sa; + struct sockaddr_vm svm; + } addr = { + .svm = { + .svm_family = AF_VSOCK, + .svm_port = port, + .svm_cid = VMADDR_CID_ANY, + }, + }; + union { + struct sockaddr sa; + struct sockaddr_vm svm; + } clientaddr; + + socklen_t clientaddr_len = sizeof(clientaddr.svm); + + printf("Run as sender\n"); + printf("Listen port %u\n", port); + printf("Send %lu bytes\n", to_send_bytes); + printf("TX buffer %lu bytes\n", buf_size_bytes); + printf("Peer buffer %lu bytes\n", vsock_buf_bytes); + + fd = socket(AF_VSOCK, SOCK_STREAM, 0); + + if (fd < 0) { + perror("socket"); + exit(EXIT_FAILURE); + } + + if (bind(fd, &addr.sa, sizeof(addr.svm)) < 0) { + perror("bind"); + exit(EXIT_FAILURE); + } + + if (listen(fd, 1) < 0) { + perror("listen"); + exit(EXIT_FAILURE); + } + + client_fd = accept(fd, &clientaddr.sa, &clientaddr_len); + + if (client_fd < 0) { + perror("accept"); + exit(EXIT_FAILURE); + } + + vsock_increase_buf_size(client_fd); + + data = malloc(buf_size_bytes); + + if (!data) { + printf("malloc failed\n"); + exit(EXIT_FAILURE); + } + + memset(data, 0, buf_size_bytes); + total_send = 0; + tx_begin_ns = current_nsec(); + + while (total_send < to_send_bytes) { + ssize_t sent; + + sent = write(client_fd, data, buf_size_bytes); + + if (sent <= 0) { + perror("write"); + exit(EXIT_FAILURE); + } + + total_send += sent; + } + + printf("tx performance: %f Gb/s\n", + get_gbps(total_send, current_nsec() - tx_begin_ns)); + + close(client_fd); + close(fd); + + free(data); +} + +static void run_receiver(int peer_cid, unsigned long rcvlowat_bytes) +{ + unsigned int read_cnt; + time_t rx_begin_ns; + time_t in_read_ns; + size_t total_recv; + void *data; + int fd; + + printf("Run as receiver\n"); + printf("Connect to %i:%u\n", peer_cid, port); + printf("RX buffer %lu bytes\n", buf_size_bytes); + printf("Peer buffer %lu bytes\n", vsock_buf_bytes); + printf("SO_RCVLOWAT %lu bytes\n", rcvlowat_bytes); + + fd = vsock_connect(peer_cid, port); + + if (fd < 0) { + perror("socket"); + exit(EXIT_FAILURE); + } + + if (setsockopt(fd, SOL_SOCKET, SO_RCVLOWAT, + &rcvlowat_bytes, + sizeof(rcvlowat_bytes))) { + perror("setsockopt"); + exit(EXIT_FAILURE); + } + + data = mmap(NULL, buf_size_bytes, PROT_READ | PROT_WRITE, + MAP_ANONYMOUS | MAP_PRIVATE | MAP_POPULATE, -1, 0); + + if (data == MAP_FAILED) { + perror("mmap"); + exit(EXIT_FAILURE); + } + + read_cnt = 0; + in_read_ns = 0; + total_recv = 0; + rx_begin_ns = current_nsec(); + + while (1) { + struct pollfd fds = { 0 }; + + fds.fd = fd; + fds.events = POLLIN | POLLERR | POLLHUP | + POLLRDHUP | POLLNVAL; + + if (poll(&fds, 1, -1) < 0) { + perror("poll"); + exit(EXIT_FAILURE); + } + + if (fds.revents & POLLERR) { + printf("'poll()' error\n"); + exit(EXIT_FAILURE); + } + + if (fds.revents & POLLIN) { + ssize_t bytes_read; + time_t t; + + t = current_nsec(); + bytes_read = read(fd, data, buf_size_bytes); + in_read_ns += (current_nsec() - t); + read_cnt++; + + if (!bytes_read) + break; + + if (bytes_read < 0) { + perror("recv"); + exit(EXIT_FAILURE); + } + + total_recv += bytes_read; + } + + if (fds.revents & (POLLHUP | POLLRDHUP)) + break; + } + + printf("rx performance: %f Gb/s\n", + get_gbps(total_recv, current_nsec() - rx_begin_ns)); + printf("total in 'read()': %f sec\n", (float)in_read_ns / NSEC_PER_SEC); + printf("POLLIN wakeups: %i\n", read_cnt); + printf("average in 'read()': %f ns\n", (float)in_read_ns / read_cnt); + + munmap(data, buf_size_bytes); + close(fd); +} + +static void usage(void) +{ + printf("Help:\n" + "\n" + "This is benchmarking utility, to test vsock performance.\n" + "It runs in two modes: sender or receiver. In sender mode, it waits\n" + "connection from receiver, and when established, sender starts data\n" + "transmission.\n" + "\n" + "Options:\n" + " -h This help message\n" + " -s Sender mode(receiver default)\n" + " -p Port (%d)\n" + " -c CID of the peer (%d)\n" + " -m Bytes to send (%d)\n" + " -b Rx/Tx buffer size (%d). In sender mode\n" + " it is size of buffer passed to 'write()'.\n" + " In receiver mode it is size of buffer passed\n" + " to 'read()'.\n" + " -v Peer buffer size (%d)\n" + " -r SO_RCVLOWAT (%d)\n" + "\n", DEFAULT_PORT, DEFAULT_CID, DEFAULT_TO_SEND_BYTES, + DEFAULT_BUF_SIZE_BYTES, DEFAULT_VSOCK_BUF_BYTES, + DEFAULT_RCVLOWAT_BYTES); + exit(EXIT_FAILURE); +} + +static long strtolx(const char *arg) +{ + long value; + char *end; + + value = strtol(arg, &end, 10); + + if (end != arg + strlen(arg)) + usage(); + + return value; +} + +int main(int argc, char **argv) +{ + unsigned long to_send_bytes = DEFAULT_TO_SEND_BYTES; + unsigned long rcvlowat_bytes = DEFAULT_RCVLOWAT_BYTES; + bool receiver_mode = true; + int peer_cid = DEFAULT_CID; + int c; + + while ((c = getopt(argc, argv, "v:r:c:p:m:b:sh")) != -1) { + switch (c) { + case 'v': /* Peer buffer size. */ + vsock_buf_bytes = memparse(optarg); + break; + case 'r': /* SO_RCVLOWAT value. */ + rcvlowat_bytes = memparse(optarg); + break; + case 'c': /* CID to connect to. */ + peer_cid = strtolx(optarg); + break; + case 'p': /* Port to connect to. */ + port = strtolx(optarg); + break; + case 'm': /* Bytes to send. */ + to_send_bytes = memparse(optarg); + break; + case 'b': /* Size of rx/tx buffer. */ + buf_size_bytes = memparse(optarg); + break; + case 's': /* Sender mode. */ + receiver_mode = false; + break; + case 'h': /* Help. */ + usage(); + break; + default: + usage(); + } + } + + if (receiver_mode) + run_receiver(peer_cid, rcvlowat_bytes); + else + run_sender(to_send_bytes); + + return 0; +}