// SPDX-License-Identifier: GPL-2.0-only
/*
* Copyright (C) 2016 Red Hat, Inc.
* Author: Michael S. Tsirkin <mst@redhat.com>
*
* Command line processing and common functions for ring benchmarking.
*/
#define _GNU_SOURCE
#include <getopt.h>
#include <pthread.h>
#include <assert.h>
#include <sched.h>
#include "main.h"
#include <sys/eventfd.h>
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <limits.h>
int runcycles = 10000000;
int max_outstanding = INT_MAX;
int batch = 1;
int param = 0;
bool do_sleep =
false;
bool do_relax =
false;
bool do_exit =
true;
unsigned ring_size = 256;
static int kickfd = -1;
static int callfd = -1;
void notify(
int fd)
{
unsigned long long v = 1;
int r;
vmexit();
r = write(fd, &v,
sizeof v);
assert(r ==
sizeof v);
vmentry();
}
void wait_for_notify(
int fd)
{
unsigned long long v = 1;
int r;
vmexit();
r = read(fd, &v,
sizeof v);
assert(r ==
sizeof v);
vmentry();
}
void kick(
void)
{
notify(kickfd);
}
void wait_for_kick(
void)
{
wait_for_notify(kickfd);
}
void call(
void)
{
notify(callfd);
}
void wait_for_call(
void)
{
wait_for_notify(callfd);
}
void set_affinity(
const char *arg)
{
cpu_set_t cpuset;
int ret;
pthread_t self;
long int cpu;
char *endptr;
if (!arg)
return;
cpu = strtol(arg, &endptr, 0);
assert(!*endptr);
assert(cpu >= 0 && cpu < CPU_SETSIZE);
self = pthread_self();
CPU_ZERO(&cpuset);
CPU_SET(cpu, &cpuset);
ret = pthread_setaffinity_np(self,
sizeof(cpu_set_t), &cpuset);
assert(!ret);
}
void poll_used(
void)
{
while (used_empty())
busy_wait();
}
static void __attribute__((__flatten__)) run_guest(
void)
{
int completed_before;
int completed = 0;
int started = 0;
int bufs = runcycles;
int spurious = 0;
int r;
unsigned len;
void *buf;
int tokick = batch;
for (;;) {
if (do_sleep)
disable_call();
completed_before = completed;
do {
if (started < bufs &&
started - completed < max_outstanding) {
r = add_inbuf(0,
"Buffer\n",
"Hello, world!");
if (__builtin_expect(r == 0,
true)) {
++started;
if (!--tokick) {
tokick = batch;
if (do_sleep)
kick_available();
}
}
}
else
r = -1;
/* Flush out completed bufs if any */
if (get_buf(&len, &buf)) {
++completed;
if (__builtin_expect(completed == bufs,
false))
return;
r = 0;
}
}
while (r == 0);
if (completed == completed_before)
++spurious;
assert(completed <= bufs);
assert(started <= bufs);
if (do_sleep) {
if (used_empty() && enable_call())
wait_for_call();
}
else {
poll_used();
}
}
}
void poll_avail(
void)
{
while (avail_empty())
busy_wait();
}
static void __attribute__((__flatten__)) run_host(
void)
{
int completed_before;
int completed = 0;
int spurious = 0;
int bufs = runcycles;
unsigned len;
void *buf;
for (;;) {
if (do_sleep) {
if (avail_empty() && enable_kick())
wait_for_kick();
}
else {
poll_avail();
}
if (do_sleep)
disable_kick();
completed_before = completed;
while (__builtin_expect(use_buf(&len, &buf),
true)) {
if (do_sleep)
call_used();
++completed;
if (__builtin_expect(completed == bufs,
false))
return;
}
if (completed == completed_before)
++spurious;
assert(completed <= bufs);
if (completed == bufs)
break;
}
}
void *start_guest(
void *arg)
{
set_affinity(arg);
run_guest();
pthread_exit(NULL);
}
void *start_host(
void *arg)
{
set_affinity(arg);
run_host();
pthread_exit(NULL);
}
static const char optstring[] =
"";
static const struct option longopts[] = {
{
.name =
"help",
.has_arg = no_argument,
.val =
'h',
},
{
.name =
"host-affinity",
.has_arg = required_argument,
.val =
'H',
},
{
.name =
"guest-affinity",
.has_arg = required_argument,
.val =
'G',
},
{
.name =
"ring-size",
.has_arg = required_argument,
.val =
'R',
},
{
.name =
"run-cycles",
.has_arg = required_argument,
.val =
'C',
},
{
.name =
"outstanding",
.has_arg = required_argument,
.val =
'o',
},
{
.name =
"batch",
.has_arg = required_argument,
.val =
'b',
},
{
.name =
"param",
.has_arg = required_argument,
.val =
'p',
},
{
.name =
"sleep",
.has_arg = no_argument,
.val =
's',
},
{
.name =
"relax",
.has_arg = no_argument,
.val =
'x',
},
{
.name =
"exit",
.has_arg = no_argument,
.val =
'e',
},
{
}
};
static void help(
void)
{
fprintf(stderr,
"Usage: [--help]"
" [--host-affinity H]"
" [--guest-affinity G]"
" [--ring-size R (default: %u)]"
" [--run-cycles C (default: %d)]"
" [--batch b]"
" [--outstanding o]"
" [--param p]"
" [--sleep]"
" [--relax]"
" [--exit]"
"\n",
ring_size,
runcycles);
}
int main(
int argc,
char **argv)
{
int ret;
pthread_t host, guest;
void *tret;
char *host_arg = NULL;
char *guest_arg = NULL;
char *endptr;
long int c;
kickfd = eventfd(0, 0);
assert(kickfd >= 0);
callfd = eventfd(0, 0);
assert(callfd >= 0);
for (;;) {
int o = getopt_long(argc, argv, optstring, longopts, NULL);
switch (o) {
case -1:
goto done;
case '?':
help();
exit(2);
case 'H':
host_arg = optarg;
break;
case 'G':
guest_arg = optarg;
break;
case 'R':
ring_size = strtol(optarg, &endptr, 0);
assert(ring_size && !(ring_size & (ring_size - 1)));
assert(!*endptr);
break;
case 'C':
c = strtol(optarg, &endptr, 0);
assert(!*endptr);
assert(c > 0 && c < INT_MAX);
runcycles = c;
break;
case 'o':
c = strtol(optarg, &endptr, 0);
assert(!*endptr);
assert(c > 0 && c < INT_MAX);
max_outstanding = c;
break;
case 'p':
c = strtol(optarg, &endptr, 0);
assert(!*endptr);
assert(c > 0 && c < INT_MAX);
param = c;
break;
case 'b':
c = strtol(optarg, &endptr, 0);
assert(!*endptr);
assert(c > 0 && c < INT_MAX);
batch = c;
break;
case 's':
do_sleep =
true;
break;
case 'x':
do_relax =
true;
break;
case 'e':
do_exit =
true;
break;
default:
help();
exit(4);
break;
}
}
/* does nothing here, used to make sure all smp APIs compile */
smp_acquire();
smp_release();
smp_mb();
done:
if (batch > max_outstanding)
batch = max_outstanding;
if (optind < argc) {
help();
exit(4);
}
alloc_ring();
ret = pthread_create(&host, NULL, start_host, host_arg);
assert(!ret);
ret = pthread_create(&guest, NULL, start_guest, guest_arg);
assert(!ret);
ret = pthread_join(guest, &tret);
assert(!ret);
ret = pthread_join(host, &tret);
assert(!ret);
return 0;
}
