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