LXR qemu/tests/bench/atomic

   1#include "qemu/osdep.h"
   2#include "qemu/thread.h"
   3#include "qemu/host-utils.h"
   4#include "qemu/processor.h"
   5#include "qemu/memalign.h"
   6
   7struct thread_info {
   8    uint64_t r;
   9} QEMU_ALIGNED(64);
  10
  11struct count {
  12    QemuMutex lock;
  13    unsigned long val;
  14} QEMU_ALIGNED(64);
  15
  16static QemuThread *threads;
  17static struct thread_info *th_info;
  18static unsigned int n_threads = 1;
  19static unsigned int n_ready_threads;
  20static struct count *counts;
  21static unsigned int duration = 1;
  22static unsigned int range = 1024;
  23static bool use_mutex;
  24static bool test_start;
  25static bool test_stop;
  26
  27static const char commands_string[] =
  28    " -n = number of threads\n"
  29    " -m = use mutexes instead of atomic increments\n"
  30    " -p = enable sync profiler\n"
  31    " -d = duration in seconds\n"
  32    " -r = range (will be rounded up to pow2)";
  33
  34static void usage_complete(char *argv[])
  35{
  36    fprintf(stderr, "Usage: %s [options]\n", argv[0]);
  37    fprintf(stderr, "options:\n%s\n", commands_string);
  38}
  39
  40/*
  41 * From: https://en.wikipedia.org/wiki/Xorshift
  42 * This is faster than rand_r(), and gives us a wider range (RAND_MAX is only
  43 * guaranteed to be >= INT_MAX).
  44 */
  45static uint64_t xorshift64star(uint64_t x)
  46{
  47    x ^= x >> 12; /* a */
  48    x ^= x << 25; /* b */
  49    x ^= x >> 27; /* c */
  50    return x * UINT64_C(2685821657736338717);
  51}
  52
  53static void *thread_func(void *arg)
  54{
  55    struct thread_info *info = arg;
  56
  57    qatomic_inc(&n_ready_threads);
  58    while (!qatomic_read(&test_start)) {
  59        cpu_relax();
  60    }
  61
  62    while (!qatomic_read(&test_stop)) {
  63        unsigned int index;
  64
  65        info->r = xorshift64star(info->r);
  66        index = info->r & (range - 1);
  67        if (use_mutex) {
  68            qemu_mutex_lock(&counts[index].lock);
  69            counts[index].val += 1;
  70            qemu_mutex_unlock(&counts[index].lock);
  71        } else {
  72            qatomic_inc(&counts[index].val);
  73        }
  74    }
  75    return NULL;
  76}
  77
  78static void run_test(void)
  79{
  80    unsigned int i;
  81
  82    while (qatomic_read(&n_ready_threads) != n_threads) {
  83        cpu_relax();
  84    }
  85
  86    qatomic_set(&test_start, true);
  87    g_usleep(duration * G_USEC_PER_SEC);
  88    qatomic_set(&test_stop, true);
  89
  90    for (i = 0; i < n_threads; i++) {
  91        qemu_thread_join(&threads[i]);
  92    }
  93}
  94
  95static void create_threads(void)
  96{
  97    unsigned int i;
  98
  99    threads = g_new(QemuThread, n_threads);
 100    th_info = g_new(struct thread_info, n_threads);
 101    counts = qemu_memalign(64, sizeof(*counts) * range);
 102    memset(counts, 0, sizeof(*counts) * range);
 103    for (i = 0; i < range; i++) {
 104        qemu_mutex_init(&counts[i].lock);
 105    }
 106
 107    for (i = 0; i < n_threads; i++) {
 108        struct thread_info *info = &th_info[i];
 109
 110        info->r = (i + 1) ^ time(NULL);
 111        qemu_thread_create(&threads[i], NULL, thread_func, info,
 112                           QEMU_THREAD_JOINABLE);
 113    }
 114}
 115
 116static void pr_params(void)
 117{
 118    printf("Parameters:\n");
 119    printf(" # of threads:      %u\n", n_threads);
 120    printf(" duration:          %u\n", duration);
 121    printf(" ops' range:        %u\n", range);
 122}
 123
 124static void pr_stats(void)
 125{
 126    unsigned long long val = 0;
 127    unsigned int i;
 128    double tx;
 129
 130    for (i = 0; i < range; i++) {
 131        val += counts[i].val;
 132    }
 133    tx = val / duration / 1e6;
 134
 135    printf("Results:\n");
 136    printf("Duration:            %u s\n", duration);
 137    printf(" Throughput:         %.2f Mops/s\n", tx);
 138    printf(" Throughput/thread:  %.2f Mops/s/thread\n", tx / n_threads);
 139}
 140
 141static void parse_args(int argc, char *argv[])
 142{
 143    int c;
 144
 145    for (;;) {
 146        c = getopt(argc, argv, "hd:n:mpr:");
 147        if (c < 0) {
 148            break;
 149        }
 150        switch (c) {
 151        case 'h':
 152            usage_complete(argv);
 153            exit(0);
 154        case 'd':
 155            duration = atoi(optarg);
 156            break;
 157        case 'n':
 158            n_threads = atoi(optarg);
 159            break;
 160        case 'm':
 161            use_mutex = true;
 162            break;
 163        case 'p':
 164            qsp_enable();
 165            break;
 166        case 'r':
 167            range = pow2ceil(atoi(optarg));
 168            break;
 169        }
 170    }
 171}
 172
 173int main(int argc, char *argv[])
 174{
 175    parse_args(argc, argv);
 176    pr_params();
 177    create_threads();
 178    run_test();
 179    pr_stats();
 180    return 0;
 181}
 182