src/libsystemd-bus/test-bus-kernel-benchmark.c

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright 2013 Lennart Poettering
   7
   8   systemd is free software; you can redistribute it and/or modify it
   9   under the terms of the GNU Lesser General Public License as published by
  10   the Free Software Foundation; either version 2.1 of the License, or
  11   (at your option) any later version.
  12
  13   systemd is distributed in the hope that it will be useful, but
  14   WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16   Lesser General Public License for more details.
  17
  18   You should have received a copy of the GNU Lesser General Public License
  19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  20 ***/
  21
  22 #include <ctype.h>
  23 #include <sys/wait.h>
  24
  25 #include "util.h"
  26 #include "log.h"
  27 #include "time-util.h"
  28
  29 #include "sd-bus.h"
  30 #include "bus-message.h"
  31 #include "bus-error.h"
  32 #include "bus-kernel.h"
  33 #include "bus-internal.h"
  34 #include "bus-util.h"
  35
  36 #define MAX_SIZE (4*1024*1024)
  37
  38 static usec_t arg_loop_usec = 100 * USEC_PER_MSEC;
  39
  40 static void server(sd_bus *b, size_t *result) {
  41         int r;
  42
  43         for (;;) {
  44                 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
  45
  46                 r = sd_bus_process(b, &m);
  47                 assert_se(r >= 0);
  48
  49                 if (r == 0)
  50                         assert_se(sd_bus_wait(b, (usec_t) -1) >= 0);
  51                 if (!m)
  52                         continue;
  53
  54                 if (sd_bus_message_is_method_call(m, "benchmark.server", "Ping"))
  55                         assert_se(sd_bus_reply_method_return(m, NULL) >= 0);
  56                 else if (sd_bus_message_is_method_call(m, "benchmark.server", "Work")) {
  57                         const void *p;
  58                         size_t sz;
  59
  60                         /* Make sure the mmap is mapped */
  61                         assert_se(sd_bus_message_read_array(m, 'y', &p, &sz) > 0);
  62
  63                         assert_se(sd_bus_reply_method_return(m, NULL) >= 0);
  64                 } else if (sd_bus_message_is_method_call(m, "benchmark.server", "Exit")) {
  65                         uint64_t res;
  66                         assert_se(sd_bus_message_read(m, "t", &res) > 0);
  67
  68                         *result = res;
  69                         return;
  70
  71                 } else
  72                         assert_not_reached("Unknown method");
  73         }
  74 }
  75
  76 static void transaction(sd_bus *b, size_t sz) {
  77         _cleanup_bus_message_unref_ sd_bus_message *m = NULL, *reply = NULL;
  78         uint8_t *p;
  79
  80         assert_se(sd_bus_message_new_method_call(b, ":1.1", "/", "benchmark.server", "Work", &m) >= 0);
  81         assert_se(sd_bus_message_append_array_space(m, 'y', sz, (void**) &p) >= 0);
  82
  83         memset(p, 0x80, sz);
  84
  85         assert_se(sd_bus_call(b, m, 0, NULL, &reply) >= 0);
  86 }
  87
  88 static void client_bisect(const char *address) {
  89         _cleanup_bus_message_unref_ sd_bus_message *x = NULL;
  90         size_t lsize, rsize, csize;
  91         sd_bus *b;
  92         int r;
  93
  94         r = sd_bus_new(&b);
  95         assert_se(r >= 0);
  96
  97         r = sd_bus_set_address(b, address);
  98         assert_se(r >= 0);
  99
 100         r = sd_bus_start(b);
 101         assert_se(r >= 0);
 102
 103         assert_se(sd_bus_call_method(b, ":1.1", "/", "benchmark.server", "Ping", NULL, NULL, NULL) >= 0);
 104
 105         lsize = 1;
 106         rsize = MAX_SIZE;
 107
 108         printf("SIZE\tCOPY\tMEMFD\n");
 109
 110         for (;;) {
 111                 usec_t t;
 112                 unsigned n_copying, n_memfd;
 113
 114                 csize = (lsize + rsize) / 2;
 115
 116                 if (csize <= lsize)
 117                         break;
 118
 119                 if (csize <= 0)
 120                         break;
 121
 122                 printf("%zu\t", csize);
 123
 124                 b->use_memfd = 0;
 125
 126                 t = now(CLOCK_MONOTONIC);
 127                 for (n_copying = 0;; n_copying++) {
 128                         transaction(b, csize);
 129                         if (now(CLOCK_MONOTONIC) >= t + arg_loop_usec)
 130                                 break;
 131                 }
 132                 printf("%u\t", (unsigned) ((n_copying * USEC_PER_SEC) / arg_loop_usec));
 133
 134                 b->use_memfd = -1;
 135
 136                 t = now(CLOCK_MONOTONIC);
 137                 for (n_memfd = 0;; n_memfd++) {
 138                         transaction(b, csize);
 139                         if (now(CLOCK_MONOTONIC) >= t + arg_loop_usec)
 140                                 break;
 141                 }
 142                 printf("%u\n", (unsigned) ((n_memfd * USEC_PER_SEC) / arg_loop_usec));
 143
 144                 if (n_copying == n_memfd)
 145                         break;
 146
 147                 if (n_copying > n_memfd)
 148                         lsize = csize;
 149                 else
 150                         rsize = csize;
 151         }
 152
 153         b->use_memfd = 1;
 154         assert_se(sd_bus_message_new_method_call(b, ":1.1", "/", "benchmark.server", "Exit", &x) >= 0);
 155         assert_se(sd_bus_message_append(x, "t", csize) >= 0);
 156         assert_se(sd_bus_send(b, x, NULL) >= 0);
 157
 158         sd_bus_unref(b);
 159 }
 160
 161 static void client_chart(const char *address) {
 162         _cleanup_bus_message_unref_ sd_bus_message *x = NULL;
 163         size_t csize;
 164         sd_bus *b;
 165         int r;
 166
 167         r = sd_bus_new(&b);
 168         assert_se(r >= 0);
 169
 170         r = sd_bus_set_address(b, address);
 171         assert_se(r >= 0);
 172
 173         r = sd_bus_start(b);
 174         assert_se(r >= 0);
 175
 176         assert_se(sd_bus_call_method(b, ":1.1", "/", "benchmark.server", "Ping", NULL, NULL, NULL) >= 0);
 177
 178         printf("SIZE\tCOPY\tMEMFD\n");
 179
 180         for (csize = 1; csize <= MAX_SIZE; csize *= 2) {
 181                 usec_t t;
 182                 unsigned n_copying, n_memfd;
 183
 184                 printf("%zu\t", csize);
 185
 186                 b->use_memfd = 0;
 187
 188                 t = now(CLOCK_MONOTONIC);
 189                 for (n_copying = 0;; n_copying++) {
 190                         transaction(b, csize);
 191                         if (now(CLOCK_MONOTONIC) >= t + arg_loop_usec)
 192                                 break;
 193                 }
 194
 195                 printf("%u\t", (unsigned) ((n_copying * USEC_PER_SEC) / arg_loop_usec));
 196
 197                 b->use_memfd = -1;
 198
 199                 t = now(CLOCK_MONOTONIC);
 200                 for (n_memfd = 0;; n_memfd++) {
 201                         transaction(b, csize);
 202                         if (now(CLOCK_MONOTONIC) >= t + arg_loop_usec)
 203                                 break;
 204                 }
 205
 206                 printf("%u\n", (unsigned) ((n_memfd * USEC_PER_SEC) / arg_loop_usec));
 207         }
 208
 209         b->use_memfd = 1;
 210         assert_se(sd_bus_message_new_method_call(b, ":1.1", "/", "benchmark.server", "Exit", &x) >= 0);
 211         assert_se(sd_bus_message_append(x, "t", csize) >= 0);
 212         assert_se(sd_bus_send(b, x, NULL) >= 0);
 213
 214         sd_bus_unref(b);
 215 }
 216
 217 int main(int argc, char *argv[]) {
 218         enum {
 219                 MODE_BISECT,
 220                 MODE_CHART,
 221         } mode = MODE_BISECT;
 222         int i;
 223         _cleanup_free_ char *bus_name = NULL, *address = NULL;
 224         _cleanup_close_ int bus_ref = -1;
 225         cpu_set_t cpuset;
 226         size_t result;
 227         sd_bus *b;
 228         pid_t pid;
 229         int r;
 230
 231         for (i = 1; i < argc; i++) {
 232                 if (streq(argv[i], "chart")) {
 233                         mode = MODE_CHART;
 234                         continue;
 235                 }
 236
 237                 assert_se(parse_sec(argv[i], &arg_loop_usec) >= 0);
 238         }
 239
 240         assert_se(arg_loop_usec > 0);
 241
 242         bus_ref = bus_kernel_create("deine-mutter", &bus_name);
 243         if (bus_ref == -ENOENT)
 244                 exit(EXIT_TEST_SKIP);
 245
 246         assert_se(bus_ref >= 0);
 247
 248         address = strappend("kernel:path=", bus_name);
 249         assert_se(address);
 250
 251         r = sd_bus_new(&b);
 252         assert_se(r >= 0);
 253
 254         r = sd_bus_set_address(b, address);
 255         assert_se(r >= 0);
 256
 257         r = sd_bus_start(b);
 258         assert_se(r >= 0);
 259
 260         sync();
 261         setpriority(PRIO_PROCESS, 0, -19);
 262
 263         pid = fork();
 264         assert_se(pid >= 0);
 265
 266         if (pid == 0) {
 267                 CPU_ZERO(&cpuset);
 268                 CPU_SET(0, &cpuset);
 269                 pthread_setaffinity_np(pthread_self(), sizeof(cpu_set_t), &cpuset);
 270
 271                 close_nointr_nofail(bus_ref);
 272                 sd_bus_unref(b);
 273
 274                 switch (mode) {
 275                 case MODE_BISECT:
 276                         client_bisect(address);
 277                         break;
 278
 279                 case MODE_CHART:
 280                         client_chart(address);
 281                         break;
 282                 }
 283
 284                 _exit(0);
 285         }
 286
 287         CPU_ZERO(&cpuset);
 288         CPU_SET(1, &cpuset);
 289         pthread_setaffinity_np(pthread_self(), sizeof(cpu_set_t), &cpuset);
 290
 291         server(b, &result);
 292
 293         if (mode == MODE_BISECT)
 294                 printf("Copying/memfd are equally fast at %zu bytes\n", result);
 295
 296         assert_se(waitpid(pid, NULL, 0) == pid);
 297
 298         sd_bus_unref(b);
 299
 300         return 0;
 301 }