tools/testing/selftests/powerpc/benchmarks/context_switch.c

   1 /*
   2  * Context switch microbenchmark.
   3  *
   4  * Copyright (C) 2015 Anton Blanchard <anton@au.ibm.com>, IBM
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License
   8  * as published by the Free Software Foundation; either version
   9  * 2 of the License, or (at your option) any later version.
  10  */
  11
  12 #define _GNU_SOURCE
  13 #include <sched.h>
  14 #include <string.h>
  15 #include <stdio.h>
  16 #include <unistd.h>
  17 #include <stdlib.h>
  18 #include <getopt.h>
  19 #include <signal.h>
  20 #include <assert.h>
  21 #include <pthread.h>
  22 #include <limits.h>
  23 #include <sys/time.h>
  24 #include <sys/syscall.h>
  25 #include <sys/sysinfo.h>
  26 #include <sys/types.h>
  27 #include <sys/shm.h>
  28 #include <linux/futex.h>
  29 #ifdef __powerpc__
  30 #include <altivec.h>
  31 #endif
  32 #include "utils.h"
  33
  34 static unsigned int timeout = 30;
  35
  36 static int touch_vdso;
  37 struct timeval tv;
  38
  39 static int touch_fp = 1;
  40 double fp;
  41
  42 static int touch_vector = 1;
  43 vector int a, b, c;
  44
  45 #ifdef __powerpc__
  46 static int touch_altivec = 1;
  47
  48 /*
  49  * Note: LTO (Link Time Optimisation) doesn't play well with this function
  50  * attribute. Be very careful enabling LTO for this test.
  51  */
  52 static void __attribute__((__target__("no-vsx"))) altivec_touch_fn(void)
  53 {
  54         c = a + b;
  55 }
  56 #endif
  57
  58 static void touch(void)
  59 {
  60         if (touch_vdso)
  61                 gettimeofday(&tv, NULL);
  62
  63         if (touch_fp)
  64                 fp += 0.1;
  65
  66 #ifdef __powerpc__
  67         if (touch_altivec)
  68                 altivec_touch_fn();
  69 #endif
  70
  71         if (touch_vector)
  72                 c = a + b;
  73
  74         asm volatile("# %0 %1 %2": : "r"(&tv), "r"(&fp), "r"(&c));
  75 }
  76
  77 static void start_thread_on(void *(*fn)(void *), void *arg, unsigned long cpu)
  78 {
  79         pthread_t tid;
  80         cpu_set_t cpuset;
  81         pthread_attr_t attr;
  82
  83         CPU_ZERO(&cpuset);
  84         CPU_SET(cpu, &cpuset);
  85
  86         pthread_attr_init(&attr);
  87
  88         if (pthread_attr_setaffinity_np(&attr, sizeof(cpu_set_t), &cpuset)) {
  89                 perror("pthread_attr_setaffinity_np");
  90                 exit(1);
  91         }
  92
  93         if (pthread_create(&tid, &attr, fn, arg)) {
  94                 perror("pthread_create");
  95                 exit(1);
  96         }
  97 }
  98
  99 static void start_process_on(void *(*fn)(void *), void *arg, unsigned long cpu)
 100 {
 101         int pid, ncpus;
 102         cpu_set_t *cpuset;
 103         size_t size;
 104
 105         pid = fork();
 106         if (pid == -1) {
 107                 perror("fork");
 108                 exit(1);
 109         }
 110
 111         if (pid)
 112                 return;
 113
 114         ncpus = get_nprocs();
 115         size = CPU_ALLOC_SIZE(ncpus);
 116         cpuset = CPU_ALLOC(ncpus);
 117         if (!cpuset) {
 118                 perror("malloc");
 119                 exit(1);
 120         }
 121         CPU_ZERO_S(size, cpuset);
 122         CPU_SET_S(cpu, size, cpuset);
 123
 124         if (sched_setaffinity(0, size, cpuset)) {
 125                 perror("sched_setaffinity");
 126                 CPU_FREE(cpuset);
 127                 exit(1);
 128         }
 129
 130         CPU_FREE(cpuset);
 131         fn(arg);
 132
 133         exit(0);
 134 }
 135
 136 static unsigned long iterations;
 137 static unsigned long iterations_prev;
 138
 139 static void sigalrm_handler(int junk)
 140 {
 141         unsigned long i = iterations;
 142
 143         printf("%ld\n", i - iterations_prev);
 144         iterations_prev = i;
 145
 146         if (--timeout == 0)
 147                 kill(0, SIGUSR1);
 148
 149         alarm(1);
 150 }
 151
 152 static void sigusr1_handler(int junk)
 153 {
 154         exit(0);
 155 }
 156
 157 struct actions {
 158         void (*setup)(int, int);
 159         void *(*thread1)(void *);
 160         void *(*thread2)(void *);
 161 };
 162
 163 #define READ 0
 164 #define WRITE 1
 165
 166 static int pipe_fd1[2];
 167 static int pipe_fd2[2];
 168
 169 static void pipe_setup(int cpu1, int cpu2)
 170 {
 171         if (pipe(pipe_fd1) || pipe(pipe_fd2))
 172                 exit(1);
 173 }
 174
 175 static void *pipe_thread1(void *arg)
 176 {
 177         signal(SIGALRM, sigalrm_handler);
 178         alarm(1);
 179
 180         while (1) {
 181                 assert(read(pipe_fd1[READ], &c, 1) == 1);
 182                 touch();
 183
 184                 assert(write(pipe_fd2[WRITE], &c, 1) == 1);
 185                 touch();
 186
 187                 iterations += 2;
 188         }
 189
 190         return NULL;
 191 }
 192
 193 static void *pipe_thread2(void *arg)
 194 {
 195         while (1) {
 196                 assert(write(pipe_fd1[WRITE], &c, 1) == 1);
 197                 touch();
 198
 199                 assert(read(pipe_fd2[READ], &c, 1) == 1);
 200                 touch();
 201         }
 202
 203         return NULL;
 204 }
 205
 206 static struct actions pipe_actions = {
 207         .setup = pipe_setup,
 208         .thread1 = pipe_thread1,
 209         .thread2 = pipe_thread2,
 210 };
 211
 212 static void yield_setup(int cpu1, int cpu2)
 213 {
 214         if (cpu1 != cpu2) {
 215                 fprintf(stderr, "Both threads must be on the same CPU for yield test\n");
 216                 exit(1);
 217         }
 218 }
 219
 220 static void *yield_thread1(void *arg)
 221 {
 222         signal(SIGALRM, sigalrm_handler);
 223         alarm(1);
 224
 225         while (1) {
 226                 sched_yield();
 227                 touch();
 228
 229                 iterations += 2;
 230         }
 231
 232         return NULL;
 233 }
 234
 235 static void *yield_thread2(void *arg)
 236 {
 237         while (1) {
 238                 sched_yield();
 239                 touch();
 240         }
 241
 242         return NULL;
 243 }
 244
 245 static struct actions yield_actions = {
 246         .setup = yield_setup,
 247         .thread1 = yield_thread1,
 248         .thread2 = yield_thread2,
 249 };
 250
 251 static long sys_futex(void *addr1, int op, int val1, struct timespec *timeout,
 252                       void *addr2, int val3)
 253 {
 254         return syscall(SYS_futex, addr1, op, val1, timeout, addr2, val3);
 255 }
 256
 257 static unsigned long cmpxchg(unsigned long *p, unsigned long expected,
 258                              unsigned long desired)
 259 {
 260         unsigned long exp = expected;
 261
 262         __atomic_compare_exchange_n(p, &exp, desired, 0,
 263                                     __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST);
 264         return exp;
 265 }
 266
 267 static unsigned long xchg(unsigned long *p, unsigned long val)
 268 {
 269         return __atomic_exchange_n(p, val, __ATOMIC_SEQ_CST);
 270 }
 271
 272 static int processes;
 273
 274 static int mutex_lock(unsigned long *m)
 275 {
 276         int c;
 277         int flags = FUTEX_WAIT;
 278         if (!processes)
 279                 flags |= FUTEX_PRIVATE_FLAG;
 280
 281         c = cmpxchg(m, 0, 1);
 282         if (!c)
 283                 return 0;
 284
 285         if (c == 1)
 286                 c = xchg(m, 2);
 287
 288         while (c) {
 289                 sys_futex(m, flags, 2, NULL, NULL, 0);
 290                 c = xchg(m, 2);
 291         }
 292
 293         return 0;
 294 }
 295
 296 static int mutex_unlock(unsigned long *m)
 297 {
 298         int flags = FUTEX_WAKE;
 299         if (!processes)
 300                 flags |= FUTEX_PRIVATE_FLAG;
 301
 302         if (*m == 2)
 303                 *m = 0;
 304         else if (xchg(m, 0) == 1)
 305                 return 0;
 306
 307         sys_futex(m, flags, 1, NULL, NULL, 0);
 308
 309         return 0;
 310 }
 311
 312 static unsigned long *m1, *m2;
 313
 314 static void futex_setup(int cpu1, int cpu2)
 315 {
 316         if (!processes) {
 317                 static unsigned long _m1, _m2;
 318                 m1 = &_m1;
 319                 m2 = &_m2;
 320         } else {
 321                 int shmid;
 322                 void *shmaddr;
 323
 324                 shmid = shmget(IPC_PRIVATE, getpagesize(), SHM_R | SHM_W);
 325                 if (shmid < 0) {
 326                         perror("shmget");
 327                         exit(1);
 328                 }
 329
 330                 shmaddr = shmat(shmid, NULL, 0);
 331                 if (shmaddr == (char *)-1) {
 332                         perror("shmat");
 333                         shmctl(shmid, IPC_RMID, NULL);
 334                         exit(1);
 335                 }
 336
 337                 shmctl(shmid, IPC_RMID, NULL);
 338
 339                 m1 = shmaddr;
 340                 m2 = shmaddr + sizeof(*m1);
 341         }
 342
 343         *m1 = 0;
 344         *m2 = 0;
 345
 346         mutex_lock(m1);
 347         mutex_lock(m2);
 348 }
 349
 350 static void *futex_thread1(void *arg)
 351 {
 352         signal(SIGALRM, sigalrm_handler);
 353         alarm(1);
 354
 355         while (1) {
 356                 mutex_lock(m2);
 357                 mutex_unlock(m1);
 358
 359                 iterations += 2;
 360         }
 361
 362         return NULL;
 363 }
 364
 365 static void *futex_thread2(void *arg)
 366 {
 367         while (1) {
 368                 mutex_unlock(m2);
 369                 mutex_lock(m1);
 370         }
 371
 372         return NULL;
 373 }
 374
 375 static struct actions futex_actions = {
 376         .setup = futex_setup,
 377         .thread1 = futex_thread1,
 378         .thread2 = futex_thread2,
 379 };
 380
 381 static struct option options[] = {
 382         { "test", required_argument, 0, 't' },
 383         { "process", no_argument, &processes, 1 },
 384         { "timeout", required_argument, 0, 's' },
 385         { "vdso", no_argument, &touch_vdso, 1 },
 386         { "no-fp", no_argument, &touch_fp, 0 },
 387 #ifdef __powerpc__
 388         { "no-altivec", no_argument, &touch_altivec, 0 },
 389 #endif
 390         { "no-vector", no_argument, &touch_vector, 0 },
 391         { 0, },
 392 };
 393
 394 static void usage(void)
 395 {
 396         fprintf(stderr, "Usage: context_switch2 <options> CPU1 CPU2\n\n");
 397         fprintf(stderr, "\t\t--test=X\tpipe, futex or yield (default)\n");
 398         fprintf(stderr, "\t\t--process\tUse processes (default threads)\n");
 399         fprintf(stderr, "\t\t--timeout=X\tDuration in seconds to run (default 30)\n");
 400         fprintf(stderr, "\t\t--vdso\t\ttouch VDSO\n");
 401         fprintf(stderr, "\t\t--no-fp\t\tDon't touch FP\n");
 402 #ifdef __powerpc__
 403         fprintf(stderr, "\t\t--no-altivec\tDon't touch altivec\n");
 404 #endif
 405         fprintf(stderr, "\t\t--no-vector\tDon't touch vector\n");
 406 }
 407
 408 int main(int argc, char *argv[])
 409 {
 410         signed char c;
 411         struct actions *actions = &yield_actions;
 412         int cpu1;
 413         int cpu2;
 414         static void (*start_fn)(void *(*fn)(void *), void *arg, unsigned long cpu);
 415
 416         while (1) {
 417                 int option_index = 0;
 418
 419                 c = getopt_long(argc, argv, "", options, &option_index);
 420
 421                 if (c == -1)
 422                         break;
 423
 424                 switch (c) {
 425                 case 0:
 426                         if (options[option_index].flag != 0)
 427                                 break;
 428
 429                         usage();
 430                         exit(1);
 431                         break;
 432
 433                 case 't':
 434                         if (!strcmp(optarg, "pipe")) {
 435                                 actions = &pipe_actions;
 436                         } else if (!strcmp(optarg, "yield")) {
 437                                 actions = &yield_actions;
 438                         } else if (!strcmp(optarg, "futex")) {
 439                                 actions = &futex_actions;
 440                         } else {
 441                                 usage();
 442                                 exit(1);
 443                         }
 444                         break;
 445
 446                 case 's':
 447                         timeout = atoi(optarg);
 448                         break;
 449
 450                 default:
 451                         usage();
 452                         exit(1);
 453                 }
 454         }
 455
 456         if (processes)
 457                 start_fn = start_process_on;
 458         else
 459                 start_fn = start_thread_on;
 460
 461         if (((argc - optind) != 2)) {
 462                 cpu1 = cpu2 = pick_online_cpu();
 463         } else {
 464                 cpu1 = atoi(argv[optind++]);
 465                 cpu2 = atoi(argv[optind++]);
 466         }
 467
 468         printf("Using %s with ", processes ? "processes" : "threads");
 469
 470         if (actions == &pipe_actions)
 471                 printf("pipe");
 472         else if (actions == &yield_actions)
 473                 printf("yield");
 474         else
 475                 printf("futex");
 476
 477         printf(" on cpus %d/%d touching FP:%s altivec:%s vector:%s vdso:%s\n",
 478                cpu1, cpu2, touch_fp ?  "yes" : "no", touch_altivec ? "yes" : "no",
 479                touch_vector ? "yes" : "no", touch_vdso ? "yes" : "no");
 480
 481         /* Create a new process group so we can signal everyone for exit */
 482         setpgid(getpid(), getpid());
 483
 484         signal(SIGUSR1, sigusr1_handler);
 485
 486         actions->setup(cpu1, cpu2);
 487
 488         start_fn(actions->thread1, NULL, cpu1);
 489         start_fn(actions->thread2, NULL, cpu2);
 490
 491         while (1)
 492                 sleep(3600);
 493
 494         return 0;
 495 }