1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * 4 * sched-pipe.c 5 * 6 * pipe: Benchmark for pipe() 7 * 8 * Based on pipe-test-1m.c by Ingo Molnar <mingo@redhat.com> 9 * http://people.redhat.com/mingo/cfs-scheduler/tools/pipe-test-1m.c 10 * Ported to perf by Hitoshi Mitake <mitake@dcl.info.waseda.ac.jp> 11 */ 12 #include <subcmd/parse-options.h> 13 #include <api/fs/fs.h> 14 #include "bench.h" 15 #include "util/cgroup.h" 16 17 #include <unistd.h> 18 #include <stdio.h> 19 #include <stdlib.h> 20 #include <signal.h> 21 #include <sys/wait.h> 22 #include <string.h> 23 #include <errno.h> 24 #include <fcntl.h> 25 #include <assert.h> 26 #include <sys/epoll.h> 27 #include <sys/time.h> 28 #include <sys/types.h> 29 #include <sys/syscall.h> 30 #include <linux/time64.h> 31 32 #include <pthread.h> 33 34 struct thread_data { 35 int nr; 36 int pipe_read; 37 int pipe_write; 38 struct epoll_event epoll_ev; 39 int epoll_fd; 40 bool cgroup_failed; 41 pthread_t pthread; 42 }; 43 44 #define LOOPS_DEFAULT 1000000 45 static int loops = LOOPS_DEFAULT; 46 47 /* Use processes by default: */ 48 static bool threaded; 49 50 static bool nonblocking; 51 static char *cgrp_names[2]; 52 static struct cgroup *cgrps[2]; 53 54 static int parse_two_cgroups(const struct option *opt __maybe_unused, 55 const char *str, int unset __maybe_unused) 56 { 57 char *p = strdup(str); 58 char *q; 59 int ret = -1; 60 61 if (p == NULL) { 62 fprintf(stderr, "memory allocation failure\n"); 63 return -1; 64 } 65 66 q = strchr(p, ','); 67 if (q == NULL) { 68 fprintf(stderr, "it should have two cgroup names: %s\n", p); 69 goto out; 70 } 71 *q = '\0'; 72 73 cgrp_names[0] = strdup(p); 74 cgrp_names[1] = strdup(q + 1); 75 76 if (cgrp_names[0] == NULL || cgrp_names[1] == NULL) { 77 fprintf(stderr, "memory allocation failure\n"); 78 goto out; 79 } 80 ret = 0; 81 82 out: 83 free(p); 84 return ret; 85 } 86 87 static const struct option options[] = { 88 OPT_BOOLEAN('n', "nonblocking", &nonblocking, "Use non-blocking operations"), 89 OPT_INTEGER('l', "loop", &loops, "Specify number of loops"), 90 OPT_BOOLEAN('T', "threaded", &threaded, "Specify threads/process based task setup"), 91 OPT_CALLBACK('G', "cgroups", NULL, "SEND,RECV", 92 "Put sender and receivers in given cgroups", 93 parse_two_cgroups), 94 OPT_END() 95 }; 96 97 static const char * const bench_sched_pipe_usage[] = { 98 "perf bench sched pipe <options>", 99 NULL 100 }; 101 102 static int enter_cgroup(int nr) 103 { 104 char buf[32]; 105 int fd, len, ret; 106 int saved_errno; 107 struct cgroup *cgrp; 108 pid_t pid; 109 110 if (cgrp_names[nr] == NULL) 111 return 0; 112 113 if (cgrps[nr] == NULL) { 114 cgrps[nr] = cgroup__new(cgrp_names[nr], /*do_open=*/true); 115 if (cgrps[nr] == NULL) 116 goto err; 117 } 118 cgrp = cgrps[nr]; 119 120 if (threaded) 121 pid = syscall(__NR_gettid); 122 else 123 pid = getpid(); 124 125 snprintf(buf, sizeof(buf), "%d\n", pid); 126 len = strlen(buf); 127 128 /* try cgroup v2 interface first */ 129 if (threaded) 130 fd = openat(cgrp->fd, "cgroup.threads", O_WRONLY); 131 else 132 fd = openat(cgrp->fd, "cgroup.procs", O_WRONLY); 133 134 /* try cgroup v1 if failed */ 135 if (fd < 0 && errno == ENOENT) 136 fd = openat(cgrp->fd, "tasks", O_WRONLY); 137 138 if (fd < 0) 139 goto err; 140 141 ret = write(fd, buf, len); 142 close(fd); 143 144 if (ret != len) { 145 printf("Cannot enter to cgroup: %s\n", cgrp->name); 146 return -1; 147 } 148 return 0; 149 150 err: 151 saved_errno = errno; 152 printf("Failed to open cgroup file in %s\n", cgrp_names[nr]); 153 154 if (saved_errno == ENOENT) { 155 char mnt[PATH_MAX]; 156 157 if (cgroupfs_find_mountpoint(mnt, sizeof(mnt), "perf_event") == 0) 158 printf(" Hint: create the cgroup first, like 'mkdir %s/%s'\n", 159 mnt, cgrp_names[nr]); 160 } else if (saved_errno == EACCES && geteuid() > 0) { 161 printf(" Hint: try to run as root\n"); 162 } 163 164 return -1; 165 } 166 167 static void exit_cgroup(int nr) 168 { 169 cgroup__put(cgrps[nr]); 170 free(cgrp_names[nr]); 171 } 172 173 static inline int read_pipe(struct thread_data *td) 174 { 175 int ret, m; 176 retry: 177 if (nonblocking) { 178 ret = epoll_wait(td->epoll_fd, &td->epoll_ev, 1, -1); 179 if (ret < 0) 180 return ret; 181 } 182 ret = read(td->pipe_read, &m, sizeof(int)); 183 if (nonblocking && ret < 0 && errno == EWOULDBLOCK) 184 goto retry; 185 return ret; 186 } 187 188 static void *worker_thread(void *__tdata) 189 { 190 struct thread_data *td = __tdata; 191 int i, ret, m = 0; 192 193 ret = enter_cgroup(td->nr); 194 if (ret < 0) { 195 td->cgroup_failed = true; 196 return NULL; 197 } 198 199 if (nonblocking) { 200 td->epoll_ev.events = EPOLLIN; 201 td->epoll_fd = epoll_create(1); 202 BUG_ON(td->epoll_fd < 0); 203 BUG_ON(epoll_ctl(td->epoll_fd, EPOLL_CTL_ADD, td->pipe_read, &td->epoll_ev) < 0); 204 } 205 206 for (i = 0; i < loops; i++) { 207 if (!td->nr) { 208 ret = read_pipe(td); 209 BUG_ON(ret != sizeof(int)); 210 ret = write(td->pipe_write, &m, sizeof(int)); 211 BUG_ON(ret != sizeof(int)); 212 } else { 213 ret = write(td->pipe_write, &m, sizeof(int)); 214 BUG_ON(ret != sizeof(int)); 215 ret = read_pipe(td); 216 BUG_ON(ret != sizeof(int)); 217 } 218 } 219 220 return NULL; 221 } 222 223 int bench_sched_pipe(int argc, const char **argv) 224 { 225 struct thread_data threads[2] = {}; 226 struct thread_data *td; 227 int pipe_1[2], pipe_2[2]; 228 struct timeval start, stop, diff; 229 unsigned long long result_usec = 0; 230 int nr_threads = 2; 231 int t; 232 233 /* 234 * why does "ret" exist? 235 * discarding returned value of read(), write() 236 * causes error in building environment for perf 237 */ 238 int __maybe_unused ret, wait_stat, flags = 0; 239 pid_t pid, retpid __maybe_unused; 240 241 argc = parse_options(argc, argv, options, bench_sched_pipe_usage, 0); 242 243 if (nonblocking) 244 flags |= O_NONBLOCK; 245 246 BUG_ON(pipe2(pipe_1, flags)); 247 BUG_ON(pipe2(pipe_2, flags)); 248 249 gettimeofday(&start, NULL); 250 251 for (t = 0; t < nr_threads; t++) { 252 td = threads + t; 253 254 td->nr = t; 255 256 if (t == 0) { 257 td->pipe_read = pipe_1[0]; 258 td->pipe_write = pipe_2[1]; 259 } else { 260 td->pipe_write = pipe_1[1]; 261 td->pipe_read = pipe_2[0]; 262 } 263 } 264 265 if (threaded) { 266 for (t = 0; t < nr_threads; t++) { 267 td = threads + t; 268 269 ret = pthread_create(&td->pthread, NULL, worker_thread, td); 270 BUG_ON(ret); 271 } 272 273 for (t = 0; t < nr_threads; t++) { 274 td = threads + t; 275 276 ret = pthread_join(td->pthread, NULL); 277 BUG_ON(ret); 278 } 279 } else { 280 pid = fork(); 281 assert(pid >= 0); 282 283 if (!pid) { 284 worker_thread(threads + 0); 285 exit(0); 286 } else { 287 worker_thread(threads + 1); 288 } 289 290 retpid = waitpid(pid, &wait_stat, 0); 291 assert((retpid == pid) && WIFEXITED(wait_stat)); 292 } 293 294 gettimeofday(&stop, NULL); 295 timersub(&stop, &start, &diff); 296 297 exit_cgroup(0); 298 exit_cgroup(1); 299 300 if (threads[0].cgroup_failed || threads[1].cgroup_failed) 301 return 0; 302 303 switch (bench_format) { 304 case BENCH_FORMAT_DEFAULT: 305 printf("# Executed %d pipe operations between two %s\n\n", 306 loops, threaded ? "threads" : "processes"); 307 308 result_usec = diff.tv_sec * USEC_PER_SEC; 309 result_usec += diff.tv_usec; 310 311 printf(" %14s: %lu.%03lu [sec]\n\n", "Total time", 312 (unsigned long) diff.tv_sec, 313 (unsigned long) (diff.tv_usec / USEC_PER_MSEC)); 314 315 printf(" %14lf usecs/op\n", 316 (double)result_usec / (double)loops); 317 printf(" %14d ops/sec\n", 318 (int)((double)loops / 319 ((double)result_usec / (double)USEC_PER_SEC))); 320 break; 321 322 case BENCH_FORMAT_SIMPLE: 323 printf("%lu.%03lu\n", 324 (unsigned long) diff.tv_sec, 325 (unsigned long) (diff.tv_usec / USEC_PER_MSEC)); 326 break; 327 328 default: 329 /* reaching here is something disaster */ 330 fprintf(stderr, "Unknown format:%d\n", bench_format); 331 exit(1); 332 break; 333 } 334 335 return 0; 336 } 337