One Level Up Top Level

test/benchmark/sembench.c - ktap

Global variables defined

Data types defined

Functions defined

Macros defined

Source code

  1. /*
  2. * copyright Oracle 2007.  Licensed under GPLv2
  3. * To compile: gcc -Wall -o sembench sembench.c -lpthread
  4. *
  5. * usage: sembench -t thread count -w wakenum -r runtime -o op
  6. * op can be: 0 (ipc sem) 1 (nanosleep) 2 (futexes)
  7. *
  8. * example:
  9. *    sembench -t 1024 -w 512 -r 60 -o 2
  10. * runs 1024 threads, waking up 512 at a time, running for 60 seconds using
  11. * futex locking.
  12. *
  13. */
  14. ‌#define  _GNU_SOURCE
  15. ‌#define _POSIX_C_SOURCE 199309
  16. #include <fcntl.h>
  17. #include <sched.h>
  18. #include <stdio.h>
  19. #include <stdlib.h>
  20. #include <sys/sem.h>
  21. #include <sys/ipc.h>
  22. #include <sys/types.h>
  23. #include <sys/mman.h>
  24. #include <pthread.h>
  25. #include <unistd.h>
  26. #include <string.h>
  27. #include <time.h>
  28. #include <sys/time.h>
  29. #include <sys/syscall.h>
  30. #include <errno.h>

  32. ‌#define VERSION "0.2"

  34. /* futexes have been around since 2.5.something, but it still seems I
  35. * need to make my own syscall.  Sigh.
  36. */
  37. ‌#define FUTEX_WAIT              0
  38. ‌#define FUTEX_WAKE              1
  39. ‌#define FUTEX_FD                2
  40. ‌#define FUTEX_REQUEUE           3
  41. ‌#define FUTEX_CMP_REQUEUE       4
  42. ‌#define FUTEX_WAKE_OP           5
  43. ‌static inline int futex (int *uaddr, int op, int val,
  44.              const struct timespec *timeout,
  45.              int *uaddr2, int val3)
  46. {
  47.     return syscall(__NR_futex, uaddr, op, val, timeout, uaddr2, val3);
  48. }

  50. ‌static void smp_mb(void)
  51. {
  52.     __sync_synchronize();
  53. }

  55. ‌static int all_done = 0;
  56. ‌static int timeout_test = 0;

  58. ‌#define SEMS_PERID 250

  60. struct sem_operations;

  62. ‌struct lockinfo {
  63.     unsigned long id;
  64.     unsigned long index;
  65.     int data;
  66.     pthread_t tid;
  67.     struct lockinfo *next;
  68.     struct sem_operations *ops;
  69.     unsigned long ready;
  70. };

  72. ‌struct sem_wakeup_info {
  73.     int wakeup_count;
  74.     struct sembuf sb[SEMS_PERID];
  75. };

  77. ‌struct sem_operations {
  78.     void (*wait)(struct lockinfo *l);
  79.     int (*wake)(struct sem_wakeup_info *wi, int num_semids, int num);
  80.     void (*setup)(struct sem_wakeup_info **wi, int num_semids);
  81.     void (*cleanup)(int num_semids);
  82.     char *name;
  83. };

  85. ‌int *semid_lookup = NULL;

  87. ‌pthread_mutex_t worklist_mutex = PTHREAD_MUTEX_INITIALIZER;
  88. ‌static unsigned long total_burns = 0;
  89. ‌static unsigned long min_burns = ~0UL;
  90. ‌static unsigned long max_burns = 0;

  92. /* currently running threads */
  93. ‌static int thread_count = 0;

  95. ‌struct lockinfo *worklist = NULL;
  96. ‌static int workers_started = 0;

  98. /* total threads started */
  99. ‌static int num_threads = 2048;

  101. ‌static void worklist_add(struct lockinfo *l)
  102. {
  103.     smp_mb();
  104.     l->ready = 1;
  105. }

  107. ‌static struct lockinfo *worklist_rm(void)
  108. {
  109.     static int last_index = 0;
  110.     int i;
  111.     struct lockinfo *l;

  113.     for (i = 0; i < num_threads; i++) {
  114.         int test = (last_index + i) % num_threads;

  116.         l = worklist + test;
  117.         smp_mb();
  118.         if (l->ready) {
  119.             l->ready = 0;
  120.             last_index = test;
  121.             return l;
  122.         }
  123.     }
  124.     return NULL;
  125. }

  127. /* ipc semaphore post& wait */
  128. ‌void wait_ipc_sem(struct lockinfo *l)
  129. {
  130.     struct sembuf sb;
  131.     int ret;
  132.     struct timespec *tvp = NULL;
  133.     struct timespec tv = { 0, 1 };

  135.     sb.sem_num = l->index;
  136.     sb.sem_flg = 0;

  138.     sb.sem_op = -1;
  139.     l->data = 1;

  141.     if (timeout_test && (l->id % 5) == 0)
  142.         tvp = &tv;

  144.     worklist_add(l);
  145.     ret = semtimedop(semid_lookup[l->id], &sb, 1, tvp);

  147.     while(l->data != 0 && tvp) {
  148.         struct timespec tv2 = { 0, 500 };
  149.         nanosleep(&tv2, NULL);
  150.     }

  152.     if (l->data != 0) {
  153.         if (tvp)
  154.             return;
  155.         fprintf(stderr, "wakeup without data update\n");
  156.         exit(1);
  157.     }
  158.     if (ret) {
  159.         if (errno == EAGAIN && tvp)
  160.             return;
  161.         perror("semtimed op");
  162.         exit(1);
  163.     }
  164. }

  166. ‌int ipc_wake_some(struct sem_wakeup_info *wi, int num_semids, int num)
  167. {
  168.     int i;
  169.     int ret;
  170.     struct lockinfo *l;
  171.     int found = 0;

  173.     for (i = 0; i < num_semids; i++) {
  174.         wi[i].wakeup_count = 0;
  175.     }
  176.     while(num > 0) {
  177.         struct sembuf *sb;
  178.         l = worklist_rm();
  179.         if (!l)
  180.             break;
  181.         if (l->data != 1)
  182.             fprintf(stderr, "warning, lockinfo data was %d\n",
  183.                 l->data);
  184.         l->data = 0;
  185.         sb = wi[l->id].sb + wi[l->id].wakeup_count;
  186.         sb->sem_num = l->index;
  187.         sb->sem_op = 1;
  188.         sb->sem_flg = IPC_NOWAIT;
  189.         wi[l->id].wakeup_count++;
  190.         found++;
  191.         num--;
  192.     }
  193.     if (!found)
  194.         return 0;
  195.     for (i = 0; i < num_semids; i++) {
  196.         int wakeup_total;
  197.         int cur;
  198.         int offset = 0;
  199.         if (!wi[i].wakeup_count)
  200.             continue;
  201.         wakeup_total = wi[i].wakeup_count;
  202.         while(wakeup_total > 0) {
  203.             cur = wakeup_total > 64 ? 64 : wakeup_total;
  204.             ret = semtimedop(semid_lookup[i], wi[i].sb + offset,
  205.                      cur, NULL);
  206.             if (ret) {
  207.                 perror("semtimedop");
  208.                 exit(1);
  209.             }
  210.             offset += cur;
  211.             wakeup_total -= cur;
  212.         }
  213.     }
  214.     return found;
  215. }

  217. ‌void setup_ipc_sems(struct sem_wakeup_info **wi, int num_semids)
  218. {
  219.     int i;
  220.     *wi = malloc(sizeof(**wi) * num_semids);
  221.     semid_lookup = malloc(num_semids * sizeof(int));
  222.     for(i = 0; i < num_semids; i++) {
  223.         semid_lookup[i] = semget(IPC_PRIVATE, SEMS_PERID,
  224.                      IPC_CREAT | 0777);
  225.         if (semid_lookup[i] < 0) {
  226.             perror("semget");
  227.             exit(1);
  228.         }
  229.     }
  230.     sleep(10);
  231. }

  233. ‌void cleanup_ipc_sems(int num)
  234. {
  235.     int i;
  236.     for (i = 0; i < num; i++) {
  237.         semctl(semid_lookup[i], 0, IPC_RMID);
  238.     }
  239. }

  241. ‌struct sem_operations ipc_sem_ops = {
  242.     .wait = wait_ipc_sem,
  243.     .wake = ipc_wake_some,
  244.     .setup = setup_ipc_sems,
  245.     .cleanup = cleanup_ipc_sems,
  246.     .name = "ipc sem operations",
  247. };

  249. /* futex post & wait */
  250. ‌void wait_futex_sem(struct lockinfo *l)
  251. {
  252.     int ret;
  253.     l->data = 1;
  254.     worklist_add(l);
  255.     while(l->data == 1) {
  256.         ret = futex(&l->data, FUTEX_WAIT, 1, NULL, NULL, 0);
  257.         /*
  258.         if (ret && ret != EWOULDBLOCK) {
  259.             perror("futex wait");
  260.             exit(1);
  261.         }*/
  262.     }
  263. }

  265. ‌int futex_wake_some(struct sem_wakeup_info *wi, int num_semids, int num)
  266. {
  267.     int i;
  268.     int ret;
  269.     struct lockinfo *l;
  270.     int found = 0;

  272.     for (i = 0; i < num; i++) {
  273.         l = worklist_rm();
  274.         if (!l)
  275.             break;
  276.         if (l->data != 1)
  277.             fprintf(stderr, "warning, lockinfo data was %d\n",
  278.                 l->data);
  279.         l->data = 0;
  280.         ret = futex(&l->data, FUTEX_WAKE, 1, NULL, NULL, 0);
  281.         if (ret < 0) {
  282.             perror("futex wake");
  283.             exit(1);
  284.         }
  285.         found++;
  286.     }
  287.     return found;
  288. }

  290. ‌void setup_futex_sems(struct sem_wakeup_info **wi, int num_semids)
  291. {
  292.     return;
  293. }

  295. ‌void cleanup_futex_sems(int num)
  296. {
  297.     return;
  298. }

  300. ‌struct sem_operations futex_sem_ops = {
  301.     .wait = wait_futex_sem,
  302.     .wake = futex_wake_some,
  303.     .setup = setup_futex_sems,
  304.     .cleanup = cleanup_futex_sems,
  305.     .name = "futex sem operations",
  306. };

  308. /* nanosleep sems here */
  309. ‌void wait_nanosleep_sem(struct lockinfo *l)
  310. {
  311.     int ret;
  312.     struct timespec tv = { 0, 1000000 };
  313.     int count = 0;

  315.     l->data = 1;
  316.     worklist_add(l);
  317.     while(l->data) {
  318.         ret = nanosleep(&tv, NULL);
  319.         if (ret) {
  320.             perror("nanosleep");
  321.             exit(1);
  322.         }
  323.         count++;
  324.     }
  325. }

  327. ‌int nanosleep_wake_some(struct sem_wakeup_info *wi, int num_semids, int num)
  328. {
  329.     int i;
  330.     struct lockinfo *l;

  332.     for (i = 0; i < num; i++) {
  333.         l = worklist_rm();
  334.         if (!l)
  335.             break;
  336.         if (l->data != 1)
  337.             fprintf(stderr, "warning, lockinfo data was %d\n",
  338.                 l->data);
  339.         l->data = 0;
  340.     }
  341.     return i;
  342. }

  344. ‌void setup_nanosleep_sems(struct sem_wakeup_info **wi, int num_semids)
  345. {
  346.     return;
  347. }

  349. ‌void cleanup_nanosleep_sems(int num)
  350. {
  351.     return;
  352. }

  354. ‌struct sem_operations nanosleep_sem_ops = {
  355.     .wait = wait_nanosleep_sem,
  356.     .wake = nanosleep_wake_some,
  357.     .setup = setup_nanosleep_sems,
  358.     .cleanup = cleanup_nanosleep_sems,
  359.     .name = "nano sleep sem operations",
  360. };

  362. ‌void *worker(void *arg)
  363. {
  364.     struct lockinfo *l = (struct lockinfo *)arg;
  365.     int burn_count = 0;
  366.     pthread_t tid = pthread_self();
  367.     size_t pagesize = getpagesize();
  368.     char *buf = malloc(pagesize);

  370.     if (!buf) {
  371.         perror("malloc");
  372.         exit(1);
  373.     }

  375.     l->tid = tid;
  376.     workers_started = 1;
  377.     smp_mb();

  379.     while(!all_done) {
  380.         l->ops->wait(l);
  381.         if (all_done)
  382.             break;
  383.         burn_count++;
  384.     }
  385.     pthread_mutex_lock(&worklist_mutex);
  386.     total_burns += burn_count;
  387.     if (burn_count < min_burns)
  388.         min_burns = burn_count;
  389.     if (burn_count > max_burns)
  390.         max_burns = burn_count;
  391.     thread_count--;
  392.     pthread_mutex_unlock(&worklist_mutex);
  393.     return (void *)0;
  394. }

  396. ‌void print_usage(void)
  397. {
  398.     printf("usage: sembench [-t threads] [-w wake incr] [-r runtime]");
  399.     printf("                [-o num] (0=ipc, 1=nanosleep, 2=futex)\n");
  400.     exit(1);
  401. }

  403. ‌#define NUM_OPERATIONS 3
  404. ‌struct sem_operations *allops[NUM_OPERATIONS] = { &ipc_sem_ops,
  405.                         &nanosleep_sem_ops,
  406.                         &futex_sem_ops};

  408. ‌int main(int ac, char **av) {
  409.     int ret;
  410.     int i;
  411.     int semid = 0;
  412.     int sem_num = 0;
  413.     int burn_count = 0;
  414.     struct sem_wakeup_info *wi = NULL;
  415.     struct timeval start;
  416.     struct timeval now;
  417.     int num_semids = 0;
  418.     int wake_num = 256;
  419.     int run_secs = 30;
  420.     int pagesize = getpagesize();
  421.     char *buf = malloc(pagesize);
  422.     struct sem_operations *ops = allops[0];
  423.     cpu_set_t cpu_mask;
  424.     cpu_set_t target_mask;
  425.     int target_cpu = 0;
  426.     int max_cpu = -1;

  428.     if (!buf) {
  429.         perror("malloc");
  430.         exit(1);
  431.     }
  432.     for (i = 1; i < ac; i++) {
  433.         if (strcmp(av[i], "-t") == 0) {
  434.             if (i == ac -1)
  435.                 print_usage();
  436.             num_threads = atoi(av[i+1]);
  437.             i++;
  438.         } else if (strcmp(av[i], "-w") == 0) {
  439.             if (i == ac -1)
  440.                 print_usage();
  441.             wake_num = atoi(av[i+1]);
  442.             i++;
  443.         } else if (strcmp(av[i], "-r") == 0) {
  444.             if (i == ac -1)
  445.                 print_usage();
  446.             run_secs = atoi(av[i+1]);
  447.             i++;
  448.         } else if (strcmp(av[i], "-o") == 0) {
  449.             int index;
  450.             if (i == ac -1)
  451.                 print_usage();
  452.             index = atoi(av[i+1]);
  453.             if (index >= NUM_OPERATIONS) {
  454.                 fprintf(stderr, "invalid operations %d\n",
  455.                     index);
  456.                 exit(1);
  457.             }
  458.             ops = allops[index];
  459.             i++;
  460.         } else if (strcmp(av[i], "-T") == 0) {
  461.             timeout_test = 1;
  462.         } else if (strcmp(av[i], "-h") == 0) {
  463.             print_usage();
  464.         }
  465.     }
  466.     num_semids = (num_threads + SEMS_PERID - 1) / SEMS_PERID;
  467.     ops->setup(&wi, num_semids);

  469.     ret = sched_getaffinity(0, sizeof(cpu_set_t), &cpu_mask);
  470.     if (ret) {
  471.         perror("sched_getaffinity");
  472.         exit(1);
  473.     }
  474.     for (i = 0; i < CPU_SETSIZE; i++)
  475.         if (CPU_ISSET(i, &cpu_mask))
  476.             max_cpu = i;
  477.     if (max_cpu == -1) {
  478.         fprintf(stderr, "sched_getaffinity returned empty mask\n");
  479.         exit(1);
  480.     }

  482.     CPU_ZERO(&target_mask);

  484.     worklist = malloc(sizeof(*worklist) * num_threads);
  485.     memset(worklist, 0, sizeof(*worklist) * num_threads);

  487.     for (i = 0; i < num_threads; i++) {
  488.         struct lockinfo *l;
  489.         pthread_t tid;
  490.         thread_count++;
  491.         l = worklist + i;
  492.         if (!l) {
  493.             perror("malloc");
  494.             exit(1);
  495.         }
  496.         l->id = semid;
  497.         l->index = sem_num++;
  498.         l->ops = ops;
  499.         if (sem_num >= SEMS_PERID) {
  500.             semid++;
  501.             sem_num = 0;
  502.         }
  503.         ret = pthread_create(&tid, NULL, worker, (void *)l);
  504.         if (ret) {
  505.             perror("pthread_create");
  506.             exit(1);
  507.         }

  509.         while (!CPU_ISSET(target_cpu, &cpu_mask)) {
  510.             target_cpu++;
  511.             if (target_cpu > max_cpu)
  512.                 target_cpu = 0;
  513.         }
  514.         CPU_SET(target_cpu, &target_mask);
  515.         ret = pthread_setaffinity_np(tid, sizeof(cpu_set_t),
  516.                          &target_mask);
  517.         CPU_CLR(target_cpu, &target_mask);
  518.         target_cpu++;

  520.         ret = pthread_detach(tid);
  521.         if (ret) {
  522.             perror("pthread_detach");
  523.             exit(1);
  524.         }
  525.     }
  526.     while(!workers_started) {
  527.         smp_mb();
  528.         usleep(200);
  529.     }
  530.     gettimeofday(&start, NULL);
  531.     //fprintf(stderr, "main loop going\n");
  532.     while(1) {
  533.         ops->wake(wi, num_semids, wake_num);
  534.         burn_count++;
  535.         gettimeofday(&now, NULL);
  536.         if (now.tv_sec - start.tv_sec >= run_secs)
  537.             break;
  538.     }
  539.     //fprintf(stderr, "all done\n");
  540.     all_done = 1;
  541.     while(thread_count > 0) {
  542.         ops->wake(wi, num_semids, wake_num);
  543.         usleep(200);
  544.     }
  545.     //printf("%d threads, waking %d at a time\n", num_threads, wake_num);
  546.     //printf("using %s\n", ops->name);
  547.     //printf("main thread burns: %d\n", burn_count);
  548.     //printf("worker burn count total %lu min %lu max %lu avg %lu\n",
  549.     //       total_burns, min_burns, max_burns, total_burns / num_threads);
  550.     printf("%d seconds: %lu worker burns per second\n",
  551.         (int)(now.tv_sec - start.tv_sec),
  552.         total_burns / (now.tv_sec - start.tv_sec));
  553.     ops->cleanup(num_semids);
  554.     return 0;
  555. }

One Level Up Top Level