testsuite/xbt/parmap_bench.c

   1 /* Copyright (c) 2012-2014. The SimGrid Team.
   2  * All rights reserved.                                                     */
   3
   4 /* This program is free software; you can redistribute it and/or modify it
   5  * under the terms of the license (GNU LGPL) which comes with this package. */
   6
   7 #include <stdio.h>
   8 #include <stdlib.h>
   9 #include <xbt/dynar.h>
  10 #include <xbt/parmap.h>
  11 #include <xbt/sysdep.h>
  12 #include <internal_config.h>        /* HAVE_FUTEX_H */
  13 #include "simgrid/simix.h"
  14 #include "xbt/xbt_os_time.h"
  15
  16 #define MODES_DEFAULT 0x7
  17 #define TIMEOUT 10.0
  18 #define ARRAY_SIZE 10007
  19 #define FIBO_MAX 25
  20
  21 void (*fun_to_apply)(void *);
  22
  23 static const char *parmap_mode_name(e_xbt_parmap_mode_t mode)
  24 {
  25   static char name[80];
  26   switch (mode) {
  27   case XBT_PARMAP_POSIX:
  28     snprintf(name, sizeof name, "POSIX");
  29     break;
  30   case XBT_PARMAP_FUTEX:
  31     snprintf(name, sizeof name, "FUTEX");
  32     break;
  33   case XBT_PARMAP_BUSY_WAIT:
  34     snprintf(name, sizeof name, "BUSY_WAIT");
  35     break;
  36   case XBT_PARMAP_DEFAULT:
  37     snprintf(name, sizeof name, "DEFAULT");
  38     break;
  39   default:
  40     snprintf(name, sizeof name, "UNKNOWN(%d)", (int)mode);
  41     break;
  42   }
  43   return name;
  44 }
  45
  46 static int parmap_skip_mode(e_xbt_parmap_mode_t mode)
  47 {
  48   switch (mode) {
  49 #ifndef HAVE_FUTEX_H
  50   case XBT_PARMAP_FUTEX:
  51     printf("not available\n");
  52     return 1;
  53 #endif
  54   default:
  55     return 0;
  56   }
  57 }
  58
  59 static unsigned fibonacci(unsigned n)
  60 {
  61   if (n < 2)
  62     return n;
  63   else
  64     return fibonacci(n - 1) + fibonacci(n - 2);
  65 }
  66
  67 static void fun_small_comp(void *arg)
  68 {
  69   unsigned *u = arg;
  70   *u = 2 * *u + 1;
  71 }
  72
  73 static void fun_big_comp(void *arg)
  74 {
  75   unsigned *u = arg;
  76   *u = fibonacci(*u % FIBO_MAX);
  77 }
  78
  79 static void array_new(unsigned **a, xbt_dynar_t *data)
  80 {
  81   int i;
  82   *a = xbt_malloc(ARRAY_SIZE * sizeof **a);
  83   *data = xbt_dynar_new(sizeof *a, NULL);
  84   xbt_dynar_shrink(*data, ARRAY_SIZE);
  85   for (i = 0 ; i < ARRAY_SIZE ; i++) {
  86     (*a)[i] = i;
  87     xbt_dynar_push_as(*data, void*, &(*a)[i]);
  88   }
  89 }
  90
  91 static void bench_parmap_full(int nthreads, e_xbt_parmap_mode_t mode)
  92 {
  93   unsigned *a;
  94   xbt_dynar_t data;
  95   xbt_parmap_t parmap;
  96   int i;
  97   double start_time, elapsed_time;
  98
  99   printf("** mode = %-15s ", parmap_mode_name(mode));
 100   fflush(stdout);
 101
 102   if (parmap_skip_mode(mode))
 103     return;
 104
 105   array_new(&a, &data);
 106
 107   i = 0;
 108   start_time = xbt_os_time();
 109   do {
 110     parmap = xbt_parmap_new(nthreads, mode);
 111     xbt_parmap_apply(parmap, fun_to_apply, data);
 112     xbt_parmap_destroy(parmap);
 113     elapsed_time = xbt_os_time() - start_time;
 114     i++;
 115   } while (elapsed_time < TIMEOUT);
 116
 117   printf("ran %d times in %g seconds (%g/s)\n",
 118          i, elapsed_time, i / elapsed_time);
 119
 120   xbt_dynar_free(&data);
 121   xbt_free(a);
 122 }
 123
 124 static void bench_parmap_apply(int nthreads, e_xbt_parmap_mode_t mode)
 125 {
 126   unsigned *a;
 127   xbt_dynar_t data;
 128   xbt_parmap_t parmap;
 129   int i;
 130   double start_time, elapsed_time;
 131
 132   printf("** mode = %-15s ", parmap_mode_name(mode));
 133   fflush(stdout);
 134
 135   if (parmap_skip_mode(mode))
 136     return;
 137
 138   array_new(&a, &data);
 139
 140   parmap = xbt_parmap_new(nthreads, mode);
 141   i = 0;
 142   start_time = xbt_os_time();
 143   do {
 144     xbt_parmap_apply(parmap, fun_to_apply, data);
 145     elapsed_time = xbt_os_time() - start_time;
 146     i++;
 147   } while (elapsed_time < TIMEOUT);
 148   xbt_parmap_destroy(parmap);
 149
 150   printf("ran %d times in %g seconds (%g/s)\n",
 151          i, elapsed_time, i / elapsed_time);
 152
 153   xbt_dynar_free(&data);
 154   xbt_free(a);
 155 }
 156
 157 static void bench_all_modes(void (*bench_fun)(int, e_xbt_parmap_mode_t),
 158                             int nthreads, unsigned modes)
 159 {
 160   e_xbt_parmap_mode_t all_modes[] = {
 161     XBT_PARMAP_POSIX, XBT_PARMAP_FUTEX,
 162     XBT_PARMAP_BUSY_WAIT, XBT_PARMAP_DEFAULT
 163   };
 164   unsigned i;
 165   for (i = 0 ; i < sizeof all_modes / sizeof all_modes[0] ; i++) {
 166     if (1U << i & modes)
 167       bench_fun(nthreads, all_modes[i]);
 168   }
 169 }
 170
 171 int main(int argc, char *argv[])
 172 {
 173   int nthreads;
 174   unsigned modes = MODES_DEFAULT;
 175
 176   SIMIX_global_init(&argc, argv);
 177
 178   if (argc != 2 && argc != 3) {
 179     fprintf(stderr,
 180             "Usage: %s nthreads [modes]\n"
 181             "    nthreads - number of working threads\n"
 182             "    modes    - bitmask of modes to test\n",
 183             argv[0]);
 184     return EXIT_FAILURE;
 185   }
 186   nthreads = atoi(argv[1]);
 187   if (nthreads < 1) {
 188     fprintf(stderr, "ERROR: invalid thread count: %d\n", nthreads);
 189     return EXIT_FAILURE;
 190   }
 191   if (argc == 3)
 192     modes = strtol(argv[2], NULL, 0);
 193
 194   printf("Parmap benchmark with %d workers (modes = %#x)...\n\n",
 195          nthreads, modes);
 196
 197   fun_to_apply = fun_small_comp;
 198
 199   printf("Benchmark for parmap create+apply+destroy (small comp):\n");
 200   bench_all_modes(bench_parmap_full, nthreads, modes);
 201   printf("\n");
 202
 203   printf("Benchmark for parmap apply only (small comp):\n");
 204   bench_all_modes(bench_parmap_apply, nthreads, modes);
 205   printf("\n");
 206
 207   fun_to_apply = fun_big_comp;
 208
 209   printf("Benchmark for parmap create+apply+destroy (big comp):\n");
 210   bench_all_modes(bench_parmap_full, nthreads, modes);
 211   printf("\n");
 212
 213   printf("Benchmark for parmap apply only (big comp):\n");
 214   bench_all_modes(bench_parmap_apply, nthreads, modes);
 215   printf("\n");
 216
 217   return EXIT_SUCCESS;
 218 }