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