From nobody Thu Apr 2 14:39:52 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 3CF75C07E9D for ; Fri, 23 Sep 2022 20:19:48 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S232933AbiIWUTp (ORCPT ); Fri, 23 Sep 2022 16:19:45 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:43638 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S232557AbiIWURP (ORCPT ); Fri, 23 Sep 2022 16:17:15 -0400 Received: from mail-wr1-x42e.google.com (mail-wr1-x42e.google.com [IPv6:2a00:1450:4864:20::42e]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 143991EC47 for ; Fri, 23 Sep 2022 13:14:40 -0700 (PDT) Received: by mail-wr1-x42e.google.com with SMTP id r7so1599739wrm.2 for ; Fri, 23 Sep 2022 13:14:39 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=arista.com; s=google; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date; bh=vGJ3kSV/z/TY65CJkdoX1ty3nkbmUWg0sp73bEAPcbA=; b=GGl8V5YYoj1u0p17YcK3WgwSDsDtSHpMdCEkuN8IZH1+JHySCBaJ9Kfh2raQeR61OP Ch0MtHEvaMwtjDjXOKFTIjnDM34qkxUeZC0hCPp560qKJseL81ovvIcvG5z97TrRUO9w SmH0FyfcjeogHKJHzLiQbNA0NvQEDotXU5VFmcu3vFgFpDAA01kIKt7+/AzahRUX0Uhc Av0HH0kFNvDEbF9cLEe40kzZRMINYGROkuqOS77PNJ2w0AjjO0VSdsva2LhnEJf5dtmx IO4ou+73F+Fv+Z1N83816cjvOSJH4FCZqR9o8K8C3tbax8aJsYzwFTwssBKboeWD5h2Y dCPQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date; bh=vGJ3kSV/z/TY65CJkdoX1ty3nkbmUWg0sp73bEAPcbA=; b=Yv2N8xgqSGvAEKo835XAMCTaC7ttdhaqs/sudlJWVrC11WLPUDJVf0dfzBkLn3Wcm4 GWZBba+83YzIeypCkkugX1TTDdv/T1+T9tHkv4ru6PVJl2SVSAVi7koDDH7Ep9SJIhPz 5CIZEi4OW5k6vGJIst7Lfve5eQjfOaxcNqXn6xjQ2ezwEEHmJVyIDATFz2z6BzKwDDjh jtyqiiMEANRzCwbfQ1a4h/rVKjvHPwb3xectPfM7x24bsafZF5iE+yOnHN8p1XrbadSH lzW4fzIAbFqwoadCklvMu5ikOQJertq5xyuVfX/W6c0+z6wIBLIanRv4vIy8WSM/bv5Y Tqag== X-Gm-Message-State: ACrzQf3msNZd7BHvI2ZTpYT0F4lhH5uVQP70FeUtUqVuhMskUCw+FZvw 24943nimMISWCKQTLkNkdyR2ifHBSHbrQQ== X-Google-Smtp-Source: AMsMyM7T3Lp+hwySehW1+5Sm0y5+nZs0WaCyuijdS7rcqqxlXSGqvQOmB8dBkYrIawXPtbQomX16Zg== X-Received: by 2002:a5d:45cc:0:b0:228:d72b:7a79 with SMTP id b12-20020a5d45cc000000b00228d72b7a79mr6005866wrs.460.1663964055199; Fri, 23 Sep 2022 13:14:15 -0700 (PDT) Received: from Mindolluin.ire.aristanetworks.com ([217.173.96.166]) by smtp.gmail.com with ESMTPSA id k11-20020a05600c0b4b00b003b492753826sm3281056wmr.43.2022.09.23.13.14.13 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 23 Sep 2022 13:14:14 -0700 (PDT) From: Dmitry Safonov To: linux-kernel@vger.kernel.org, David Ahern , Eric Dumazet Cc: Dmitry Safonov , Andy Lutomirski , Ard Biesheuvel , Bob Gilligan , Dan Carpenter , "David S. Miller" , Dmitry Safonov <0x7f454c46@gmail.com>, Eric Biggers , "Eric W. Biederman" , Francesco Ruggeri , Herbert Xu , Hideaki YOSHIFUJI , Ivan Delalande , Jakub Kicinski , Leonard Crestez , Paolo Abeni , Salam Noureddine , Shuah Khan , netdev@vger.kernel.org, linux-crypto@vger.kernel.org Subject: [PATCH v2 31/35] selftests/aolib: Add test/benchmark for removing MKTs Date: Fri, 23 Sep 2022 21:13:15 +0100 Message-Id: <20220923201319.493208-32-dima@arista.com> X-Mailer: git-send-email 2.37.2 In-Reply-To: <20220923201319.493208-1-dima@arista.com> References: <20220923201319.493208-1-dima@arista.com> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" Sample output: > 1..36 > # 1106[lib/setup.c:207] rand seed 1660754406 > TAP version 13 > ok 1 Worst case connect 512 keys: min=3D0ms max=3D1ms mean=3D0.58= 3329ms stddev=3D0.076376 > ok 2 Connect random-search 512 keys: min=3D0ms max=3D1ms mean=3D0.53= 412ms stddev=3D0.0516779 > ok 3 Worst case delete 512 keys: min=3D2ms max=3D11ms mean=3D6.0= 4139ms stddev=3D0.245792 > ok 4 Add a new key 512 keys: min=3D0ms max=3D13ms mean=3D0.6= 73415ms stddev=3D0.0820618 > ok 5 Remove random-search 512 keys: min=3D5ms max=3D9ms mean=3D6.65= 969ms stddev=3D0.258064 > ok 6 Remove async 512 keys: min=3D0ms max=3D0ms mean=3D0.04= 1825ms stddev=3D0.0204512 > ok 7 Worst case connect 1024 keys: min=3D0ms max=3D2ms mean=3D0.5= 20357ms stddev=3D0.0721358 > ok 8 Connect random-search 1024 keys: min=3D0ms max=3D2ms mean=3D0.5= 35312ms stddev=3D0.0517355 > ok 9 Worst case delete 1024 keys: min=3D5ms max=3D9ms mean=3D8.2= 7219ms stddev=3D0.287614 > ok 10 Add a new key 1024 keys: min=3D0ms max=3D1ms mean=3D0.6= 88121ms stddev=3D0.0829531 > ok 11 Remove random-search 1024 keys: min=3D5ms max=3D9ms mean=3D8.3= 7649ms stddev=3D0.289422 > ok 12 Remove async 1024 keys: min=3D0ms max=3D0ms mean=3D0.0= 457096ms stddev=3D0.0213798 > ok 13 Worst case connect 2048 keys: min=3D0ms max=3D2ms mean=3D0.7= 48804ms stddev=3D0.0865335 > ok 14 Connect random-search 2048 keys: min=3D0ms max=3D2ms mean=3D0.7= 82993ms stddev=3D0.0625697 > ok 15 Worst case delete 2048 keys: min=3D5ms max=3D10ms mean=3D8.= 23106ms stddev=3D0.286898 > ok 16 Add a new key 2048 keys: min=3D0ms max=3D1ms mean=3D0.8= 12988ms stddev=3D0.0901658 > ok 17 Remove random-search 2048 keys: min=3D8ms max=3D9ms mean=3D8.8= 4949ms stddev=3D0.297481 > ok 18 Remove async 2048 keys: min=3D0ms max=3D0ms mean=3D0.0= 297223ms stddev=3D0.0172402 > ok 19 Worst case connect 4096 keys: min=3D1ms max=3D5ms mean=3D1.5= 3352ms stddev=3D0.123836 > ok 20 Connect random-search 4096 keys: min=3D1ms max=3D5ms mean=3D1.5= 2226ms stddev=3D0.0872429 > ok 21 Worst case delete 4096 keys: min=3D5ms max=3D9ms mean=3D8.2= 5874ms stddev=3D0.28738 > ok 22 Add a new key 4096 keys: min=3D0ms max=3D3ms mean=3D1.6= 7382ms stddev=3D0.129376 > ok 23 Remove random-search 4096 keys: min=3D5ms max=3D10ms mean=3D8.= 26178ms stddev=3D0.287433 > ok 24 Remove async 4096 keys: min=3D0ms max=3D0ms mean=3D0.0= 340009ms stddev=3D0.0184393 > ok 25 Worst case connect 8192 keys: min=3D2ms max=3D4ms mean=3D2.8= 6208ms stddev=3D0.169177 > ok 26 Connect random-search 8192 keys: min=3D2ms max=3D4ms mean=3D2.8= 7592ms stddev=3D0.119915 > ok 27 Worst case delete 8192 keys: min=3D6ms max=3D11ms mean=3D7.= 55291ms stddev=3D0.274826 > ok 28 Add a new key 8192 keys: min=3D1ms max=3D5ms mean=3D2.5= 6797ms stddev=3D0.160249 > ok 29 Remove random-search 8192 keys: min=3D5ms max=3D10ms mean=3D7.= 14002ms stddev=3D0.267208 > ok 30 Remove async 8192 keys: min=3D0ms max=3D0ms mean=3D0.0= 320066ms stddev=3D0.0178904 > ok 31 Worst case connect 16384 keys: min=3D5ms max=3D6ms mean=3D5.= 55334ms stddev=3D0.235655 > ok 32 Connect random-search 16384 keys: min=3D5ms max=3D6ms mean=3D5.= 52614ms stddev=3D0.166225 > ok 33 Worst case delete 16384 keys: min=3D5ms max=3D11ms mean=3D7= .39109ms stddev=3D0.271866 > ok 34 Add a new key 16384 keys: min=3D2ms max=3D4ms mean=3D3.= 35799ms stddev=3D0.183248 > ok 35 Remove random-search 16384 keys: min=3D5ms max=3D8ms mean=3D6.= 86078ms stddev=3D0.261931 > ok 36 Remove async 16384 keys: min=3D0ms max=3D0ms mean=3D0.= 0302384ms stddev=3D0.0173892 > # Totals: pass:36 fail:0 xfail:0 xpass:0 skip:0 error:0 From it it's visible that the current simplified approach with linked-list of MKTs scales quite fine even for thousands of keys. And that also means that the majority of the time for delete is eaten by synchronize_rcu() [which I can confirm separately by tracing]. Signed-off-by: Dmitry Safonov --- tools/testing/selftests/net/tcp_ao/Makefile | 4 +- .../selftests/net/tcp_ao/bench-lookups.c | 403 ++++++++++++++++++ 2 files changed, 406 insertions(+), 1 deletion(-) create mode 100644 tools/testing/selftests/net/tcp_ao/bench-lookups.c diff --git a/tools/testing/selftests/net/tcp_ao/Makefile b/tools/testing/se= lftests/net/tcp_ao/Makefile index da44966f3687..a4af7d4da169 100644 --- a/tools/testing/selftests/net/tcp_ao/Makefile +++ b/tools/testing/selftests/net/tcp_ao/Makefile @@ -1,6 +1,6 @@ # SPDX-License-Identifier: GPL-2.0 TEST_BOTH_AF :=3D connect icmps-discard icmps-accept connect-deny \ - setsockopt-closed unsigned-md5 + setsockopt-closed unsigned-md5 bench-lookups =20 TEST_IPV4_PROGS :=3D $(TEST_BOTH_AF:%=3D%_ipv4) TEST_IPV6_PROGS :=3D $(TEST_BOTH_AF:%=3D%_ipv6) @@ -46,3 +46,5 @@ $(OUTPUT)/%_ipv6: %.c =20 $(OUTPUT)/icmps-accept_ipv4: CFLAGS+=3D -DTEST_ICMPS_ACCEPT $(OUTPUT)/icmps-accept_ipv6: CFLAGS+=3D -DTEST_ICMPS_ACCEPT +$(OUTPUT)/bench-lookups_ipv4: LDFLAGS+=3D -lm +$(OUTPUT)/bench-lookups_ipv6: LDFLAGS+=3D -lm diff --git a/tools/testing/selftests/net/tcp_ao/bench-lookups.c b/tools/tes= ting/selftests/net/tcp_ao/bench-lookups.c new file mode 100644 index 000000000000..41456d85e06a --- /dev/null +++ b/tools/testing/selftests/net/tcp_ao/bench-lookups.c @@ -0,0 +1,403 @@ +// SPDX-License-Identifier: GPL-2.0 +/* Author: Dmitry Safonov */ +#include +#include +#include +#include +#include +#include + +#include "../../../../include/linux/bits.h" +#include "../../../../include/linux/kernel.h" +#include "aolib.h" + +#define AO_KEY_SZ 300 /* ~=3D sizeof(struct tcp_ao_key) */ +#define NR_ITERS 100 /* number of times to run gathering statistics */ + +#ifdef IPV6_TEST +typedef struct in6_addr ipaddr_t; +static ipaddr_t get_ipaddr_t(ipaddr_t net, size_t n) +{ + ipaddr_t ret =3D net; + + ret.s6_addr32[3] =3D htonl(n & (BIT(32) - 1)); + ret.s6_addr32[2] =3D htonl((n >> 32) & (BIT(32) - 1)); + + return ret; +} +#else +typedef struct in_addr ipaddr_t; +static ipaddr_t get_ipaddr_t(ipaddr_t net, size_t n) +{ + ipaddr_t ret; + + ret.s_addr =3D htonl(ntohl(net.s_addr) + n); + return ret; +} +#endif + +static void gen_test_ips(ipaddr_t *ips, size_t ips_nr, bool use_rand) +{ + ipaddr_t net; + size_t i, j; + + if (inet_pton(TEST_FAMILY, TEST_NETWORK, &net) !=3D 1) + test_error("Can't convert ip address %s", TEST_NETWORK); + + if (!use_rand) { + for (i =3D 0; i < ips_nr; i++) + ips[i] =3D get_ipaddr_t(net, 2 * i + 1); + return; + } + for (i =3D 0; i < ips_nr; i++) { + size_t r =3D (size_t)random() | 0x1; + + ips[i] =3D get_ipaddr_t(net, r); + + for (j =3D i - 1; j > 0 && i > 0; j--) { + if (!memcmp(&ips[i], &ips[j], sizeof(ipaddr_t))) { + i--; /* collision */ + break; + } + } + } +} + +static void test_add_routes(ipaddr_t *ips, size_t ips_nr) +{ + size_t i; + + for (i =3D 0; i < ips_nr; i++) { + union tcp_addr *p =3D (union tcp_addr *)&ips[i]; + + if (ip_route_add(veth_name, TEST_FAMILY, this_ip_addr, *p)) + test_error("Failed to add route"); + } +} + +static void server_apply_keys(int lsk, ipaddr_t *ips, size_t ips_nr) +{ + size_t i; + + for (i =3D 0; i < ips_nr; i++) { + union tcp_addr *p =3D (union tcp_addr *)&ips[i]; + + if (test_set_ao(lsk, "password", 0, *p, -1, 100, 100)) + test_error("setsockopt(TCP_AO)"); + } +} + +static const size_t nr_keys[] =3D { 512, 1024, 2048, 4096, 8192, 16384 }; +static ipaddr_t *test_ips; + +struct bench_stats { + uint64_t min; + uint64_t max; + uint64_t nr; + double mean; + double s2; +}; + +static struct bench_tests { + struct bench_stats delete_last_key; + struct bench_stats add_key; + struct bench_stats delete_rand_key; + struct bench_stats connect_last_key; + struct bench_stats connect_rand_key; + struct bench_stats delete_async; +} bench_results[ARRAY_SIZE(nr_keys)]; + +#define NSEC_PER_SEC 1000000000ULL + +static void measure_call(struct bench_stats *st, + void (*f)(int, void *), int sk, void *arg) +{ + struct timespec start =3D {}, end =3D {}; + double delta; + uint64_t nsec; + + if (clock_gettime(CLOCK_MONOTONIC, &start)) + test_error("clock_gettime()"); + + f(sk, arg); + + if (clock_gettime(CLOCK_MONOTONIC, &end)) + test_error("clock_gettime()"); + + nsec =3D (end.tv_sec - start.tv_sec) * NSEC_PER_SEC; + if (end.tv_nsec >=3D start.tv_nsec) + nsec +=3D end.tv_nsec - start.tv_nsec; + else + nsec -=3D start.tv_nsec - end.tv_nsec; + + if (st->nr =3D=3D 0) { + st->min =3D st->max =3D nsec; + } else { + if (st->min > nsec) + st->min =3D nsec; + if (st->max < nsec) + st->max =3D nsec; + } + + /* Welford-Knuth algorithm */ + st->nr++; + delta =3D (double)nsec - st->mean; + st->mean +=3D delta / st->nr; + st->s2 +=3D delta * ((double)nsec - st->mean); +} + +static void delete_mkt(int sk, void *arg) +{ + struct tcp_ao_del *ao =3D arg; + + if (setsockopt(sk, IPPROTO_TCP, TCP_AO_DEL, ao, sizeof(*ao))) + test_error("setsockopt(TCP_AO_DEL)"); +} + +static void add_back_mkt(int sk, void *arg) +{ + union tcp_addr *p =3D arg; + + if (test_set_ao(sk, "password", 0, *p, -1, 100, 100)) + test_error("setsockopt(TCP_AO)"); +} + +static void memcpy_sockaddr(void *dest, union tcp_addr *in_addr) +{ +#ifdef IPV6_TEST + struct sockaddr_in6 addr =3D { + .sin6_family =3D AF_INET6, + .sin6_port =3D 0, + .sin6_addr =3D in_addr->a6, + }; +#else + struct sockaddr_in addr =3D { + .sin_family =3D AF_INET, + .sin_port =3D 0, + .sin_addr =3D in_addr->a4, + }; +#endif + + memcpy(dest, &addr, sizeof(addr)); +} + +static void bench_delete(int lsk, struct bench_stats *add, + struct bench_stats *del, + ipaddr_t *ips, size_t ips_nr, + bool rand_order, bool async) +{ + struct tcp_ao_del ao_del =3D {}; + union tcp_addr *p; + size_t i; + + ao_del.tcpa_sndid =3D 100; + ao_del.tcpa_rcvid =3D 100; + if (async) + ao_del.tcpa_flags =3D TCP_AO_CMDF_DEL_ASYNC; + ao_del.tcpa_prefix =3D DEFAULT_TEST_PREFIX; + + /* Remove the first added */ + p =3D (union tcp_addr *)&ips[0]; + memcpy_sockaddr(&ao_del.tcpa_addr, p); + + for (i =3D 0; i < NR_ITERS; i++) { + measure_call(del, delete_mkt, lsk, (void *)&ao_del); + + /* Restore it back */ + measure_call(add, add_back_mkt, lsk, (void *)p); + + /* + * Slowest for FILO-linked-list: + * on (i) iteration removing ips[i] element. When it gets + * added to the list back - it becomes first to fetch, so + * on (i + 1) iteration go to ips[i + 1] element. + */ + if (rand_order) + p =3D (union tcp_addr *)&ips[rand() % ips_nr]; + else + p =3D (union tcp_addr *)&ips[i % ips_nr]; + memcpy_sockaddr(&ao_del.tcpa_addr, p); + } +} + +static void bench_connect_srv(int lsk, ipaddr_t *ips, size_t ips_nr) +{ + size_t i; + + for (i =3D 0; i < NR_ITERS; i++) { + int err, sk; + + synchronize_threads(); + + err =3D test_wait_fd(lsk, TEST_TIMEOUT_SEC, 0); + if (!err) + test_error("timeouted for accept()"); + else if (err < 0) + test_error("test_wait_fd()"); + + sk =3D accept(lsk, NULL, NULL); + if (sk < 0) + test_error("accept()"); + + close(sk); + } +} + +static void test_print_stats(const char *desc, size_t nr, struct bench_sta= ts *bs) +{ + test_ok("%20s\t%zu keys: min=3D%" PRIu64 "ms max=3D%" PRIu64 "ms mean=3D%= gms stddev=3D%g", + desc, nr, bs->min / 1000000, bs->max / 1000000, + bs->mean / 1000000, sqrt((bs->mean / 1000000) / bs->nr)); +} + +static void *server_fn(void *arg) +{ + size_t i; + + for (i =3D 0; i < ARRAY_SIZE(nr_keys); i++) { + struct bench_tests *bt =3D &bench_results[i]; + int lsk; + + test_ips =3D malloc(nr_keys[i] * sizeof(ipaddr_t)); + if (!test_ips) + test_error("malloc()"); + + lsk =3D test_listen_socket(this_ip_addr, test_server_port + i, 1); + + gen_test_ips(test_ips, nr_keys[i], false); + test_add_routes(test_ips, nr_keys[i]); + test_set_optmem(AO_KEY_SZ * nr_keys[i]); + server_apply_keys(lsk, test_ips, nr_keys[i]); + + synchronize_threads(); + bench_connect_srv(lsk, test_ips, nr_keys[i]); + bench_connect_srv(lsk, test_ips, nr_keys[i]); + + /* The worst case for FILO-list */ + bench_delete(lsk, &bt->add_key, &bt->delete_last_key, + test_ips, nr_keys[i], false, false); + test_print_stats("Worst case delete", + nr_keys[i], &bt->delete_last_key); + test_print_stats("Add a new key", + nr_keys[i], &bt->add_key); + + bench_delete(lsk, &bt->add_key, &bt->delete_rand_key, + test_ips, nr_keys[i], true, false); + test_print_stats("Remove random-search", + nr_keys[i], &bt->delete_rand_key); + + bench_delete(lsk, &bt->add_key, &bt->delete_async, + test_ips, nr_keys[i], false, true); + test_print_stats("Remove async", nr_keys[i], &bt->delete_async); + + free(test_ips); + close(lsk); + } + + return NULL; +} + +static void connect_client(int sk, void *arg) +{ + size_t *p =3D arg; + + if (test_connect_socket(sk, this_ip_dest, test_server_port + *p) <=3D 0) + test_error("failed to connect()"); +} + +static void client_addr_setup(int sk, union tcp_addr taddr) +{ +#ifdef IPV6_TEST + struct sockaddr_in6 addr =3D { + .sin6_family =3D AF_INET6, + .sin6_port =3D 0, + .sin6_addr =3D taddr.a6, + }; +#else + struct sockaddr_in addr =3D { + .sin_family =3D AF_INET, + .sin_port =3D 0, + .sin_addr =3D taddr.a4, + }; +#endif + int ret; + + ret =3D ip_addr_add(veth_name, TEST_FAMILY, taddr, TEST_PREFIX); + if (ret && ret !=3D -EEXIST) + test_error("Failed to add ip address"); + ret =3D ip_route_add(veth_name, TEST_FAMILY, taddr, this_ip_dest); + if (ret && ret !=3D -EEXIST) + test_error("Failed to add route"); + + if (bind(sk, &addr, sizeof(addr))) + test_error("bind()"); +} + +static void bench_connect_client(size_t port_off, struct bench_tests *bt, + ipaddr_t *ips, size_t ips_nr, bool rand_order) +{ + struct bench_stats *con; + union tcp_addr *p; + size_t i; + + if (rand_order) + con =3D &bt->connect_rand_key; + else + con =3D &bt->connect_last_key; + + p =3D (union tcp_addr *)&ips[0]; + + for (i =3D 0; i < NR_ITERS; i++) { + int sk =3D socket(test_family, SOCK_STREAM, IPPROTO_TCP); + + if (sk < 0) + test_error("socket()"); + + client_addr_setup(sk, *p); + if (test_set_ao(sk, "password", 0, this_ip_dest, -1, 100, 100)) + test_error("setsockopt(TCP_AO)"); + + synchronize_threads(); + + measure_call(con, connect_client, sk, (void *)&port_off); + + close(sk); + + /* + * Slowest for FILO-linked-list: + * on (i) iteration removing ips[i] element. When it gets + * added to the list back - it becomes first to fetch, so + * on (i + 1) iteration go to ips[i + 1] element. + */ + if (rand_order) + p =3D (union tcp_addr *)&ips[rand() % ips_nr]; + else + p =3D (union tcp_addr *)&ips[i % ips_nr]; + } +} + +static void *client_fn(void *arg) +{ + size_t i; + + for (i =3D 0; i < ARRAY_SIZE(nr_keys); i++) { + struct bench_tests *bt =3D &bench_results[i]; + + synchronize_threads(); + bench_connect_client(i, bt, test_ips, nr_keys[i], false); + test_print_stats("Worst case connect", + nr_keys[i], &bt->connect_last_key); + + bench_connect_client(i, bt, test_ips, nr_keys[i], false); + test_print_stats("Connect random-search", + nr_keys[i], &bt->connect_last_key); + } + synchronize_threads(); + return NULL; +} + +int main(int argc, char *argv[]) +{ + test_init(36, server_fn, client_fn); + return 0; +} --=20 2.37.2