qemu

FORK: QEMU emulator
git clone https://git.neptards.moe/neptards/qemu.git
Log | Files | Refs | Submodules | LICENSE

atomic_add-bench.c (4242B)

      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 
      7 struct thread_info {
      8     uint64_t r;
      9 } QEMU_ALIGNED(64);
     10 
     11 struct count {
     12     QemuMutex lock;
     13     unsigned long val;
     14 } QEMU_ALIGNED(64);
     15 
     16 static QemuThread *threads;
     17 static struct thread_info *th_info;
     18 static unsigned int n_threads = 1;
     19 static unsigned int n_ready_threads;
     20 static struct count *counts;
     21 static unsigned int duration = 1;
     22 static unsigned int range = 1024;
     23 static bool use_mutex;
     24 static bool test_start;
     25 static bool test_stop;
     26 
     27 static 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 
     34 static 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  */
     45 static 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 
     53 static 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 
     78 static 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 
     95 static 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 
    116 static 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 
    124 static 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 
    141 static 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 
    173 int 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 }