xref: /openbmc/linux/tools/virtio/ringtest/main.c (revision 4f6cce39) 
1 /*
2  * Copyright (C) 2016 Red Hat, Inc.
3  * Author: Michael S. Tsirkin <mst@redhat.com>
4  * This work is licensed under the terms of the GNU GPL, version 2.
5  *
6  * Command line processing and common functions for ring benchmarking.
7  */
8 #define _GNU_SOURCE
9 #include <getopt.h>
10 #include <pthread.h>
11 #include <assert.h>
12 #include <sched.h>
13 #include "main.h"
14 #include <sys/eventfd.h>
15 #include <stdlib.h>
16 #include <stdio.h>
17 #include <unistd.h>
18 #include <limits.h>
19 
20 int runcycles = 10000000;
21 int max_outstanding = INT_MAX;
22 int batch = 1;
23 
24 bool do_sleep = false;
25 bool do_relax = false;
26 bool do_exit = true;
27 
28 unsigned ring_size = 256;
29 
30 static int kickfd = -1;
31 static int callfd = -1;
32 
33 void notify(int fd)
34 {
35 	unsigned long long v = 1;
36 	int r;
37 
38 	vmexit();
39 	r = write(fd, &v, sizeof v);
40 	assert(r == sizeof v);
41 	vmentry();
42 }
43 
44 void wait_for_notify(int fd)
45 {
46 	unsigned long long v = 1;
47 	int r;
48 
49 	vmexit();
50 	r = read(fd, &v, sizeof v);
51 	assert(r == sizeof v);
52 	vmentry();
53 }
54 
55 void kick(void)
56 {
57 	notify(kickfd);
58 }
59 
60 void wait_for_kick(void)
61 {
62 	wait_for_notify(kickfd);
63 }
64 
65 void call(void)
66 {
67 	notify(callfd);
68 }
69 
70 void wait_for_call(void)
71 {
72 	wait_for_notify(callfd);
73 }
74 
75 void set_affinity(const char *arg)
76 {
77 	cpu_set_t cpuset;
78 	int ret;
79 	pthread_t self;
80 	long int cpu;
81 	char *endptr;
82 
83 	if (!arg)
84 		return;
85 
86 	cpu = strtol(arg, &endptr, 0);
87 	assert(!*endptr);
88 
89 	assert(cpu >= 0 || cpu < CPU_SETSIZE);
90 
91 	self = pthread_self();
92 	CPU_ZERO(&cpuset);
93 	CPU_SET(cpu, &cpuset);
94 
95 	ret = pthread_setaffinity_np(self, sizeof(cpu_set_t), &cpuset);
96 	assert(!ret);
97 }
98 
99 void poll_used(void)
100 {
101 	while (used_empty())
102 		busy_wait();
103 }
104 
105 static void __attribute__((__flatten__)) run_guest(void)
106 {
107 	int completed_before;
108 	int completed = 0;
109 	int started = 0;
110 	int bufs = runcycles;
111 	int spurious = 0;
112 	int r;
113 	unsigned len;
114 	void *buf;
115 	int tokick = batch;
116 
117 	for (;;) {
118 		if (do_sleep)
119 			disable_call();
120 		completed_before = completed;
121 		do {
122 			if (started < bufs &&
123 			    started - completed < max_outstanding) {
124 				r = add_inbuf(0, "Buffer\n", "Hello, world!");
125 				if (__builtin_expect(r == 0, true)) {
126 					++started;
127 					if (!--tokick) {
128 						tokick = batch;
129 						if (do_sleep)
130 							kick_available();
131 					}
132 
133 				}
134 			} else
135 				r = -1;
136 
137 			/* Flush out completed bufs if any */
138 			if (get_buf(&len, &buf)) {
139 				++completed;
140 				if (__builtin_expect(completed == bufs, false))
141 					return;
142 				r = 0;
143 			}
144 		} while (r == 0);
145 		if (completed == completed_before)
146 			++spurious;
147 		assert(completed <= bufs);
148 		assert(started <= bufs);
149 		if (do_sleep) {
150 			if (used_empty() && enable_call())
151 				wait_for_call();
152 		} else {
153 			poll_used();
154 		}
155 	}
156 }
157 
158 void poll_avail(void)
159 {
160 	while (avail_empty())
161 		busy_wait();
162 }
163 
164 static void __attribute__((__flatten__)) run_host(void)
165 {
166 	int completed_before;
167 	int completed = 0;
168 	int spurious = 0;
169 	int bufs = runcycles;
170 	unsigned len;
171 	void *buf;
172 
173 	for (;;) {
174 		if (do_sleep) {
175 			if (avail_empty() && enable_kick())
176 				wait_for_kick();
177 		} else {
178 			poll_avail();
179 		}
180 		if (do_sleep)
181 			disable_kick();
182 		completed_before = completed;
183 		while (__builtin_expect(use_buf(&len, &buf), true)) {
184 			if (do_sleep)
185 				call_used();
186 			++completed;
187 			if (__builtin_expect(completed == bufs, false))
188 				return;
189 		}
190 		if (completed == completed_before)
191 			++spurious;
192 		assert(completed <= bufs);
193 		if (completed == bufs)
194 			break;
195 	}
196 }
197 
198 void *start_guest(void *arg)
199 {
200 	set_affinity(arg);
201 	run_guest();
202 	pthread_exit(NULL);
203 }
204 
205 void *start_host(void *arg)
206 {
207 	set_affinity(arg);
208 	run_host();
209 	pthread_exit(NULL);
210 }
211 
212 static const char optstring[] = "";
213 static const struct option longopts[] = {
214 	{
215 		.name = "help",
216 		.has_arg = no_argument,
217 		.val = 'h',
218 	},
219 	{
220 		.name = "host-affinity",
221 		.has_arg = required_argument,
222 		.val = 'H',
223 	},
224 	{
225 		.name = "guest-affinity",
226 		.has_arg = required_argument,
227 		.val = 'G',
228 	},
229 	{
230 		.name = "ring-size",
231 		.has_arg = required_argument,
232 		.val = 'R',
233 	},
234 	{
235 		.name = "run-cycles",
236 		.has_arg = required_argument,
237 		.val = 'C',
238 	},
239 	{
240 		.name = "outstanding",
241 		.has_arg = required_argument,
242 		.val = 'o',
243 	},
244 	{
245 		.name = "batch",
246 		.has_arg = required_argument,
247 		.val = 'b',
248 	},
249 	{
250 		.name = "sleep",
251 		.has_arg = no_argument,
252 		.val = 's',
253 	},
254 	{
255 		.name = "relax",
256 		.has_arg = no_argument,
257 		.val = 'x',
258 	},
259 	{
260 		.name = "exit",
261 		.has_arg = no_argument,
262 		.val = 'e',
263 	},
264 	{
265 	}
266 };
267 
268 static void help(void)
269 {
270 	fprintf(stderr, "Usage: <test> [--help]"
271 		" [--host-affinity H]"
272 		" [--guest-affinity G]"
273 		" [--ring-size R (default: %d)]"
274 		" [--run-cycles C (default: %d)]"
275 		" [--batch b]"
276 		" [--outstanding o]"
277 		" [--sleep]"
278 		" [--relax]"
279 		" [--exit]"
280 		"\n",
281 		ring_size,
282 		runcycles);
283 }
284 
285 int main(int argc, char **argv)
286 {
287 	int ret;
288 	pthread_t host, guest;
289 	void *tret;
290 	char *host_arg = NULL;
291 	char *guest_arg = NULL;
292 	char *endptr;
293 	long int c;
294 
295 	kickfd = eventfd(0, 0);
296 	assert(kickfd >= 0);
297 	callfd = eventfd(0, 0);
298 	assert(callfd >= 0);
299 
300 	for (;;) {
301 		int o = getopt_long(argc, argv, optstring, longopts, NULL);
302 		switch (o) {
303 		case -1:
304 			goto done;
305 		case '?':
306 			help();
307 			exit(2);
308 		case 'H':
309 			host_arg = optarg;
310 			break;
311 		case 'G':
312 			guest_arg = optarg;
313 			break;
314 		case 'R':
315 			ring_size = strtol(optarg, &endptr, 0);
316 			assert(ring_size && !(ring_size & (ring_size - 1)));
317 			assert(!*endptr);
318 			break;
319 		case 'C':
320 			c = strtol(optarg, &endptr, 0);
321 			assert(!*endptr);
322 			assert(c > 0 && c < INT_MAX);
323 			runcycles = c;
324 			break;
325 		case 'o':
326 			c = strtol(optarg, &endptr, 0);
327 			assert(!*endptr);
328 			assert(c > 0 && c < INT_MAX);
329 			max_outstanding = c;
330 			break;
331 		case 'b':
332 			c = strtol(optarg, &endptr, 0);
333 			assert(!*endptr);
334 			assert(c > 0 && c < INT_MAX);
335 			batch = c;
336 			break;
337 		case 's':
338 			do_sleep = true;
339 			break;
340 		case 'x':
341 			do_relax = true;
342 			break;
343 		case 'e':
344 			do_exit = true;
345 			break;
346 		default:
347 			help();
348 			exit(4);
349 			break;
350 		}
351 	}
352 
353 	/* does nothing here, used to make sure all smp APIs compile */
354 	smp_acquire();
355 	smp_release();
356 	smp_mb();
357 done:
358 
359 	if (batch > max_outstanding)
360 		batch = max_outstanding;
361 
362 	if (optind < argc) {
363 		help();
364 		exit(4);
365 	}
366 	alloc_ring();
367 
368 	ret = pthread_create(&host, NULL, start_host, host_arg);
369 	assert(!ret);
370 	ret = pthread_create(&guest, NULL, start_guest, guest_arg);
371 	assert(!ret);
372 
373 	ret = pthread_join(guest, &tret);
374 	assert(!ret);
375 	ret = pthread_join(host, &tret);
376 	assert(!ret);
377 	return 0;
378 }
379