[splice.git] / splice-bench.c

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <limits.h>
#include <string.h>
#include <getopt.h>
#include <errno.h>
#include <fcntl.h>
#include <sys/poll.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/time.h>
#include <sys/mman.h>
#include <signal.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <sched.h>

#include "splice.h"

static int nr_clients = 8;
static int net_port = 8888;
static int client_loops = 10;
static int bind_cpu;
static int write_to_null;
static int same_file;
static int splice_size = SPLICE_SIZE;
static char *filename = "splice-file";
static unsigned int max_client_run = 15;
static int run_rw = 1;
static int run_splice = 1;
static int run_mmap = 1;

static int nr_cpus;

static int usage(char *name)
{
	fprintf(stderr, "Usage %s [options] [filename]:\n", name);
	fprintf(stderr, "\t[-n] (number of clients]\n");
	fprintf(stderr, "\t[-p] (port number)\n");
	fprintf(stderr, "\t[-l] (number of loops)\n");
	fprintf(stderr, "\t[-z] (write to /dev/null)\n");
	fprintf(stderr, "\t[-s] (use 1 file for all)\n");
	fprintf(stderr, "\t[-a] (set CPU affinity)\n");
	fprintf(stderr, "\t[-b] (splice chunk size)\n");
	fprintf(stderr, "\t[-t] (max client runtime in seconds)\n");
	fprintf(stderr, "\t[-c] (clients to run (rw/mmap/splice)\n");
	return 1;
}

static int parse_options(int argc, char *argv[])
{
	int c, index = 1;

	while ((c = getopt(argc, argv, "n:p:l:azsb:t:c:")) != -1) {
		switch (c) {
		case 'n':
			nr_clients = atoi(optarg);
			index++;
			break;
		case 'p':
			net_port = atoi(optarg);
			index++;
			break;
		case 'l':
			client_loops = atoi(optarg);
			index++;
			break;
		case 'a':
			bind_cpu = 1;
			index++;
			break;
		case 'z':
			write_to_null = 1;
			index++;
			break;
		case 's':
			same_file = 1;
			index++;
			break;
		case 'b':
			splice_size = atoi(optarg);
			index++;
			break;
		case 't':
			max_client_run = atoi(optarg);
			index++;
			break;
		case 'c':
			if (!strstr(optarg, "rw"))
				run_rw = 0;
			if (!strstr(optarg, "splice"))
				run_splice = 0;
			if (!strstr(optarg, "mmap"))
				run_mmap = 0;
			index++;
			break;
		default:
			return -1;
		}
	}

	return index;
}

static int bind_to_cpu(int index)
{
	cpu_set_t cpu_mask;
	pid_t pid;
	int cpu;

	if (!bind_cpu || nr_cpus == 1)
		return 0;

	cpu = index % nr_cpus;

	CPU_ZERO(&cpu_mask);
	CPU_SET((cpu), &cpu_mask);

	pid = getpid();
	if (sched_setaffinity(pid, sizeof(cpu_mask), &cpu_mask) == -1)
		return error("set affinity");

	return 0;
}

static int accept_loop(int listen_sk)
{
	struct sockaddr addr;
	unsigned int len = sizeof(addr);
	int sk;

again:
	sk = accept(listen_sk, &addr, &len);
	if (sk < 0)
		return error("accept");

	/* read forever */
	for (;;) {
		int ret = recv(sk, NULL, 128*1024*1024, MSG_TRUNC);
		if (ret > 0)
			continue;
		else if (!ret)
			break;
		if (errno == EAGAIN || errno == EINTR)
			continue;
		break;
	}

	close(sk);
	goto again;
}

static int server(int offset)
{
	struct sockaddr_in saddr_in;
	struct sockaddr addr;
	unsigned int len;
	int sk, opt;

	bind_to_cpu(offset);
	nice(-20);

	sk = socket(PF_INET, SOCK_STREAM, 0);
	if (sk < 0)
		return error("socket");

	opt = 1;
	if (setsockopt(sk, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)) < 0)
		return error("setsockopt");

	saddr_in.sin_addr.s_addr = htonl(INADDR_ANY);
	saddr_in.sin_port = htons(net_port + offset);

	if (bind(sk, (struct sockaddr *) &saddr_in, sizeof(saddr_in)) < 0)
		return error("bind");

	if (listen(sk, 1) < 0)
		return error("listen");

	len = sizeof(addr);
	if (getsockname(sk, &addr, &len) < 0)
		return error("getsockname");

	return accept_loop(sk);
}

static unsigned long mtime_since(struct timeval *s, struct timeval *e)
{
	double sec, usec;

	sec = e->tv_sec - s->tv_sec;
	usec = e->tv_usec - s->tv_usec;
	if (sec > 0 && usec < 0) {
		sec--;
		usec += 1000000;
	}

	sec *= (double) 1000;
	usec /= (double) 1000;

	return sec + usec;
}

static unsigned long mtime_since_now(struct timeval *s)
{
	struct timeval t;

	gettimeofday(&t, NULL);
	return mtime_since(s, &t);
}

static int client_rw(int out_fd, int file_fd, int offset)
{
	int loops = client_loops;
	struct timeval start;
	struct stat sb;
	char *buf;
	unsigned long long size;
	unsigned long msecs;

	if (fstat(file_fd, &sb) < 0)
		return error("fstat");

	buf = malloc(splice_size);

	gettimeofday(&start, NULL);
again:
	if (lseek(file_fd, 0, SEEK_SET) < 0)
		return error("lseek");

	size = sb.st_size;
	while (size) {
		int this_len = min(size, (unsigned long long) splice_size);
		int ret = read(file_fd, buf, this_len);

		if (ret < 0)
			return error("read");

		size -= ret;
		while (ret) {
			int written = write(out_fd, buf, ret);

			if (written < 0)
				return error("write");

			ret -= written;
		}
	}

	loops--;

	if ((mtime_since_now(&start) < max_client_run * 1000) && loops)
		goto again;

	free(buf);
	size = sb.st_size >> 10;
	size *= (client_loops - loops);
	msecs = mtime_since_now(&start);
	fprintf(stdout, "Client%d (rw): %Lu MiB/sec (%LuMiB in %lu msecs)\n", offset, size / (unsigned long long) msecs, size >> 10, msecs);
	return 0;
}

static int client_mmap(int out_fd, int file_fd, int offset)
{
	int loops = client_loops;
	struct timeval start;
	struct stat sb;
	void *mmap_area, *buf;
	unsigned long long size;
	unsigned long msecs;

	if (fstat(file_fd, &sb) < 0)
		return error("fstat");

	mmap_area = mmap(NULL, sb.st_size, PROT_READ, MAP_SHARED, file_fd, 0);
	if (mmap_area == MAP_FAILED)
		return error("mmap");

	if (madvise(mmap_area, sb.st_size, MADV_WILLNEED) < 0)
		return error("madvise");

	gettimeofday(&start, NULL);
again:
	buf = mmap_area;
	size = sb.st_size;
	while (size) {
		int this_len = min(size, (unsigned long long) splice_size);
		int ret = write(out_fd, buf, this_len);

		if (ret < 0)
			return error("write");

		buf += ret;
		size -= ret;
	}

	loops--;

	if ((mtime_since_now(&start) < max_client_run * 1000) && loops)
		goto again;

	size = sb.st_size >> 10;
	size *= (client_loops - loops);
	msecs = mtime_since_now(&start);
	fprintf(stdout, "Client%d (mmap): %Lu MiB/sec (%LuMiB in %lu msecs)\n", offset, size / (unsigned long long) msecs, size >> 10, msecs);
	munmap(mmap_area, sb.st_size);
	return 0;

}

static int client_splice_loop(int out_fd, int fd, int *pfd, int offset)
{
	struct timeval start;
	unsigned long long size;
	unsigned long msecs;
	struct stat sb;
	int loops = client_loops;
	loff_t off;

	if (fstat(fd, &sb) < 0)
		return error("fstat");

	gettimeofday(&start, NULL);
again:
	size = sb.st_size;
	off = 0;

	do {
		int ret = ssplice(fd, &off, pfd[1], NULL, min(size, (unsigned long long) splice_size), 0);

		if (ret <= 0)
			return error("splice-in");

		size -= ret;
		while (ret > 0) {
			int flags = size ? SPLICE_F_MORE : 0;
			int written = ssplice(pfd[0], NULL, out_fd, NULL, ret, flags);

			if (written <= 0)
				return error("splice-out");

			ret -= written;
		}
	} while (size);

	loops--;

	if ((mtime_since_now(&start) < max_client_run * 1000) && loops)
		goto again;

	size = sb.st_size >> 10;
	size *= (client_loops - loops);
	msecs = mtime_since_now(&start);
	fprintf(stdout, "Client%d (splice): %Lu MiB/sec (%LuMiB in %lu msecs)\n", offset, size / (unsigned long long) msecs, size >> 10, msecs);
	return 0;
}

static int client_splice(int out_fd, int file_fd, int offset)
{
	int pfd[2], ret;

	if (pipe(pfd) < 0)
		return error("pipe");
	
	ret = client_splice_loop(out_fd, file_fd, pfd, offset);
	close(pfd[0]);
	close(pfd[1]);
	return ret;
}

static int do_client(int out_fd, int file_fd, int offset)
{
	int ret;

	if (run_splice) {
		ret = client_splice(out_fd, file_fd, offset);
		if (ret)
			return ret;
	}
	if (run_mmap) {
		ret = client_mmap(out_fd, file_fd, offset);
		if (ret)
			return ret;
	}
	if (run_rw) {
		ret = client_rw(out_fd, file_fd, offset);
		if (ret)
			return ret;
	}
	return 0;
}

static int client_open_net(int offset)
{
	int sk = socket(PF_INET, SOCK_STREAM, 0);
	struct sockaddr_in s_to;
	struct hostent *hp;

	hp = gethostbyname("localhost");
	if (!hp)
		return error("gethostbyname");

	bzero((char *) &s_to, sizeof (s_to));
	bcopy((char *) hp->h_addr, (char *) &(s_to.sin_addr), hp->h_length);
	s_to.sin_family = hp->h_addrtype;
	s_to.sin_port = htons(net_port + offset);

	if (connect(sk, (struct sockaddr *)&s_to, sizeof(s_to)) < 0)
		return error("connect");

	return sk;
}

static int client(int offset)
{
	int file_fd, out_fd;
	char fname[64];

	bind_to_cpu(offset);
	nice(-20);

	if (!write_to_null)
		out_fd = client_open_net(offset);
	else
		out_fd = open("/dev/null", O_WRONLY);

	if (out_fd < 0)
		return error("socket");

	sprintf(fname, "%s%d", filename, same_file ? 0 : offset);
	file_fd = open(fname, O_RDONLY);
	if (file_fd < 0)
		return error("open");

	return do_client(out_fd, file_fd, offset);
}

int main(int argc, char *argv[])
{
	pid_t *spids, *cpids;
	int i, index;

	index = parse_options(argc, argv);
	if (index < 0)
		return usage(argv[0]);

	if (index < argc)
		filename = argv[index];

	spids = malloc(nr_clients * sizeof(pid_t));
	cpids = malloc(nr_clients * sizeof(pid_t));
	memset(spids, 0, nr_clients * sizeof(pid_t));
	memset(cpids, 0, nr_clients * sizeof(pid_t));

	nr_cpus = sysconf(_SC_NPROCESSORS_ONLN);
	if (nr_cpus < 0)
		return error("_SC_NPROCESSORS_ONLN");

	/*
	 * fork servers
	 */
	if (!write_to_null) {
		for (i = 0; i < nr_clients; i++) {
			pid_t pid = fork();

			if (pid)
				spids[i] = pid;
			else {
				server(i);
				spids[i] = 0;
				exit(0);
			}
		}
		sleep(1); /* should have servers started now */
	}

	/*
	 * fork clients
	 */
	for (i = 0; i < nr_clients; i++) {
		pid_t pid = fork();

		if (pid)
			cpids[i] = pid;
		else {
			client(i);
			cpids[i] = 0;
			exit(0);
		}
	}

	/*
	 * wait for clients to exit
	 */
	fprintf(stdout, "Waiting for clients\n");
	for (i = 0; i < nr_clients; i++) {
		if (cpids[i]) {
			waitpid(cpids[i], NULL, 0);
			cpids[i] = 0;
		}
	}

	/*
	 * then kill servers
	 */
	for (i = 0; i < nr_clients; i++) {
		if (spids[i]) {
			kill(spids[i], SIGKILL);
			waitpid(spids[i], NULL, 0);
			spids[i] = 0;
		}
	}

	return 0;
}
Commit	Line	Data
d7b40d65 JA	1	#include <stdio.h>
	2	#include <stdlib.h>
	3	#include <unistd.h>
	4	#include <limits.h>
	5	#include <string.h>
	6	#include <getopt.h>
	7	#include <errno.h>
	8	#include <fcntl.h>
	9	#include <sys/poll.h>
	10	#include <sys/stat.h>
	11	#include <sys/types.h>
	12	#include <sys/wait.h>
	13	#include <sys/time.h>
be35036e	14	#include <sys/mman.h>
d7b40d65 JA	15	#include <signal.h>
	16	#include <netinet/in.h>
	17	#include <arpa/inet.h>
	18	#include <netdb.h>
	19	#include <sched.h>
	20
	21	#include "splice.h"
	22
	23	static int nr_clients = 8;
	24	static int net_port = 8888;
	25	static int client_loops = 10;
	26	static int bind_cpu;
	27	static int write_to_null;
	28	static int same_file;
	29	static int splice_size = SPLICE_SIZE;
	30	static char *filename = "splice-file";
000b72a8	31	static unsigned int max_client_run = 15;
be35036e JA	32	static int run_rw = 1;
	33	static int run_splice = 1;
	34	static int run_mmap = 1;
d7b40d65 JA	35
	36	static int nr_cpus;
	37
	38	static int usage(char *name)
	39	{
	40	fprintf(stderr, "Usage %s [options] [filename]:\n", name);
	41	fprintf(stderr, "\t[-n] (number of clients]\n");
	42	fprintf(stderr, "\t[-p] (port number)\n");
	43	fprintf(stderr, "\t[-l] (number of loops)\n");
	44	fprintf(stderr, "\t[-z] (write to /dev/null)\n");
	45	fprintf(stderr, "\t[-s] (use 1 file for all)\n");
	46	fprintf(stderr, "\t[-a] (set CPU affinity)\n");
	47	fprintf(stderr, "\t[-b] (splice chunk size)\n");
be35036e JA	48	fprintf(stderr, "\t[-t] (max client runtime in seconds)\n");
be35036e JA	49	fprintf(stderr, "\t[-c] (clients to run (rw/mmap/splice)\n");
d7b40d65 JA	50	return 1;
	51	}
	52
	53	static int parse_options(int argc, char *argv[])
	54	{
	55	int c, index = 1;
	56
be35036e	57	while ((c = getopt(argc, argv, "n:p:l:azsb:t:c:")) != -1) {
d7b40d65 JA	58	switch (c) {
	59	case 'n':
	60	nr_clients = atoi(optarg);
	61	index++;
	62	break;
	63	case 'p':
	64	net_port = atoi(optarg);
	65	index++;
	66	break;
	67	case 'l':
	68	client_loops = atoi(optarg);
	69	index++;
	70	break;
	71	case 'a':
	72	bind_cpu = 1;
	73	index++;
	74	break;
	75	case 'z':
	76	write_to_null = 1;
	77	index++;
	78	break;
	79	case 's':
	80	same_file = 1;
	81	index++;
	82	break;
	83	case 'b':
	84	splice_size = atoi(optarg);
	85	index++;
	86	break;
be35036e JA	87	case 't':
	88	max_client_run = atoi(optarg);
	89	index++;
	90	break;
	91	case 'c':
	92	if (!strstr(optarg, "rw"))
	93	run_rw = 0;
	94	if (!strstr(optarg, "splice"))
	95	run_splice = 0;
	96	if (!strstr(optarg, "mmap"))
	97	run_mmap = 0;
	98	index++;
	99	break;
d7b40d65 JA	100	default:
	101	return -1;
	102	}
	103	}
	104
	105	return index;
	106	}
	107
a4ecdc0a	108	static int bind_to_cpu(int index)
d7b40d65 JA	109	{
	110	cpu_set_t cpu_mask;
	111	pid_t pid;
	112	int cpu;
	113
	114	if (!bind_cpu \|\| nr_cpus == 1)
	115	return 0;
	116
	117	cpu = index % nr_cpus;
	118
	119	CPU_ZERO(&cpu_mask);
	120	CPU_SET((cpu), &cpu_mask);
	121
	122	pid = getpid();
	123	if (sched_setaffinity(pid, sizeof(cpu_mask), &cpu_mask) == -1)
	124	return error("set affinity");
	125
	126	return 0;
	127	}
	128
a4ecdc0a	129	static int accept_loop(int listen_sk)
d7b40d65	130	{
d7b40d65 JA	131	struct sockaddr addr;
	132	unsigned int len = sizeof(addr);
	133	int sk;
	134
	135	again:
	136	sk = accept(listen_sk, &addr, &len);
	137	if (sk < 0)
	138	return error("accept");
	139
	140	/* read forever */
d7b40d65 JA	141	for (;;) {
d7b40d65 JA	142	int ret = recv(sk, NULL, 12810241024, MSG_TRUNC);
a4ecdc0a	143	if (ret > 0)
d7b40d65	144	continue;
a4ecdc0a	145	else if (!ret)
d7b40d65 JA	146	break;
	147	if (errno == EAGAIN \|\| errno == EINTR)
	148	continue;
	149	break;
	150	}
	151
	152	close(sk);
	153	goto again;
	154	}
	155
a4ecdc0a	156	static int server(int offset)
d7b40d65	157	{
d7b40d65	158	struct sockaddr_in saddr_in;
a4ecdc0a	159	struct sockaddr addr;
d7b40d65	160	unsigned int len;
659cd2cc	161	int sk, opt;
d7b40d65 JA	162
	163	bind_to_cpu(offset);
	164	nice(-20);
	165
	166	sk = socket(PF_INET, SOCK_STREAM, 0);
	167	if (sk < 0)
	168	return error("socket");
	169
659cd2cc JA	170	opt = 1;
	171	if (setsockopt(sk, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)) < 0)
	172	return error("setsockopt");
	173
d7b40d65 JA	174	saddr_in.sin_addr.s_addr = htonl(INADDR_ANY);
	175	saddr_in.sin_port = htons(net_port + offset);
	176
659cd2cc	177	if (bind(sk, (struct sockaddr *) &saddr_in, sizeof(saddr_in)) < 0)
d7b40d65 JA	178	return error("bind");
	179
	180	if (listen(sk, 1) < 0)
	181	return error("listen");
	182
	183	len = sizeof(addr);
	184	if (getsockname(sk, &addr, &len) < 0)
	185	return error("getsockname");
	186
	187	return accept_loop(sk);
	188	}
	189
	190	static unsigned long mtime_since(struct timeval s, struct timeval e)
	191	{
	192	double sec, usec;
	193
	194	sec = e->tv_sec - s->tv_sec;
	195	usec = e->tv_usec - s->tv_usec;
	196	if (sec > 0 && usec < 0) {
	197	sec--;
	198	usec += 1000000;
	199	}
	200
	201	sec *= (double) 1000;
	202	usec /= (double) 1000;
	203
	204	return sec + usec;
	205	}
	206
	207	static unsigned long mtime_since_now(struct timeval *s)
	208	{
	209	struct timeval t;
	210
	211	gettimeofday(&t, NULL);
	212	return mtime_since(s, &t);
	213	}
	214
a4ecdc0a	215	static int client_rw(int out_fd, int file_fd, int offset)
be35036e JA	216	{
	217	int loops = client_loops;
	218	struct timeval start;
	219	struct stat sb;
	220	char *buf;
	221	unsigned long long size;
	222	unsigned long msecs;
	223
	224	if (fstat(file_fd, &sb) < 0)
	225	return error("fstat");
	226
	227	buf = malloc(splice_size);
	228
	229	gettimeofday(&start, NULL);
	230	again:
	231	if (lseek(file_fd, 0, SEEK_SET) < 0)
	232	return error("lseek");
	233
	234	size = sb.st_size;
	235	while (size) {
	236	int this_len = min(size, (unsigned long long) splice_size);
	237	int ret = read(file_fd, buf, this_len);
	238
	239	if (ret < 0)
	240	return error("read");
	241
	242	size -= ret;
	243	while (ret) {
	244	int written = write(out_fd, buf, ret);
	245
	246	if (written < 0)
	247	return error("write");
	248
	249	ret -= written;
	250	}
	251	}
	252
	253	loops--;
	254
	255	if ((mtime_since_now(&start) < max_client_run * 1000) && loops)
	256	goto again;
	257
a4ecdc0a	258	free(buf);
be35036e JA	259	size = sb.st_size >> 10;
	260	size *= (client_loops - loops);
	261	msecs = mtime_since_now(&start);
	262	fprintf(stdout, "Client%d (rw): %Lu MiB/sec (%LuMiB in %lu msecs)\n", offset, size / (unsigned long long) msecs, size >> 10, msecs);
	263	return 0;
	264	}
	265
a4ecdc0a	266	static int client_mmap(int out_fd, int file_fd, int offset)
be35036e JA	267	{
	268	int loops = client_loops;
	269	struct timeval start;
	270	struct stat sb;
	271	void mmap_area, buf;
	272	unsigned long long size;
	273	unsigned long msecs;
	274
	275	if (fstat(file_fd, &sb) < 0)
	276	return error("fstat");
	277
	278	mmap_area = mmap(NULL, sb.st_size, PROT_READ, MAP_SHARED, file_fd, 0);
	279	if (mmap_area == MAP_FAILED)
	280	return error("mmap");
	281
	282	if (madvise(mmap_area, sb.st_size, MADV_WILLNEED) < 0)
	283	return error("madvise");
	284
	285	gettimeofday(&start, NULL);
	286	again:
	287	buf = mmap_area;
	288	size = sb.st_size;
	289	while (size) {
	290	int this_len = min(size, (unsigned long long) splice_size);
	291	int ret = write(out_fd, buf, this_len);
	292
	293	if (ret < 0)
	294	return error("write");
	295
	296	buf += ret;
	297	size -= ret;
	298	}
	299
	300	loops--;
	301
	302	if ((mtime_since_now(&start) < max_client_run * 1000) && loops)
	303	goto again;
	304
	305	size = sb.st_size >> 10;
	306	size *= (client_loops - loops);
	307	msecs = mtime_since_now(&start);
	308	fprintf(stdout, "Client%d (mmap): %Lu MiB/sec (%LuMiB in %lu msecs)\n", offset, size / (unsigned long long) msecs, size >> 10, msecs);
	309	munmap(mmap_area, sb.st_size);
	310	return 0;
	311
	312	}
	313
a4ecdc0a	314	static int client_splice_loop(int out_fd, int fd, int *pfd, int offset)
d7b40d65 JA	315	{
	316	struct timeval start;
	317	unsigned long long size;
	318	unsigned long msecs;
	319	struct stat sb;
	320	int loops = client_loops;
	321	loff_t off;
	322
	323	if (fstat(fd, &sb) < 0)
	324	return error("fstat");
	325
	326	gettimeofday(&start, NULL);
d7b40d65 JA	327	again:
	328	size = sb.st_size;
	329	off = 0;
	330
	331	do {
13b72067	332	int ret = ssplice(fd, &off, pfd[1], NULL, min(size, (unsigned long long) splice_size), 0);
d7b40d65 JA	333
	334	if (ret <= 0)
	335	return error("splice-in");
	336
	337	size -= ret;
	338	while (ret > 0) {
	339	int flags = size ? SPLICE_F_MORE : 0;
13b72067	340	int written = ssplice(pfd[0], NULL, out_fd, NULL, ret, flags);
d7b40d65 JA	341
	342	if (written <= 0)
	343	return error("splice-out");
	344
	345	ret -= written;
	346	}
	347	} while (size);
	348
be35036e JA	349	loops--;
	350
	351	if ((mtime_since_now(&start) < max_client_run * 1000) && loops)
d7b40d65 JA	352	goto again;
	353
	354	size = sb.st_size >> 10;
be35036e	355	size *= (client_loops - loops);
d7b40d65	356	msecs = mtime_since_now(&start);
be35036e JA	357	fprintf(stdout, "Client%d (splice): %Lu MiB/sec (%LuMiB in %lu msecs)\n", offset, size / (unsigned long long) msecs, size >> 10, msecs);
	358	return 0;
	359	}
	360
a4ecdc0a	361	static int client_splice(int out_fd, int file_fd, int offset)
be35036e JA	362	{
	363	int pfd[2], ret;
	364
	365	if (pipe(pfd) < 0)
	366	return error("pipe");
	367
	368	ret = client_splice_loop(out_fd, file_fd, pfd, offset);
	369	close(pfd[0]);
	370	close(pfd[1]);
	371	return ret;
	372	}
	373
a4ecdc0a	374	static int do_client(int out_fd, int file_fd, int offset)
be35036e	375	{
4f4118c9 JA	376	int ret;
	377
	378	if (run_splice) {
	379	ret = client_splice(out_fd, file_fd, offset);
	380	if (ret)
	381	return ret;
	382	}
	383	if (run_mmap) {
	384	ret = client_mmap(out_fd, file_fd, offset);
	385	if (ret)
	386	return ret;
	387	}
	388	if (run_rw) {
	389	ret = client_rw(out_fd, file_fd, offset);
	390	if (ret)
	391	return ret;
	392	}
d7b40d65 JA	393	return 0;
	394	}
	395
	396	static int client_open_net(int offset)
	397	{
	398	int sk = socket(PF_INET, SOCK_STREAM, 0);
	399	struct sockaddr_in s_to;
	400	struct hostent *hp;
	401
	402	hp = gethostbyname("localhost");
	403	if (!hp)
	404	return error("gethostbyname");
	405
	406	bzero((char *) &s_to, sizeof (s_to));
	407	bcopy((char ) hp->h_addr, (char ) &(s_to.sin_addr), hp->h_length);
	408	s_to.sin_family = hp->h_addrtype;
	409	s_to.sin_port = htons(net_port + offset);
	410
	411	if (connect(sk, (struct sockaddr *)&s_to, sizeof(s_to)) < 0)
	412	return error("connect");
	413
	414	return sk;
	415	}
	416
a4ecdc0a	417	static int client(int offset)
d7b40d65 JA	418	{
	419	int file_fd, out_fd;
	420	char fname[64];
d7b40d65 JA	421
	422	bind_to_cpu(offset);
	423	nice(-20);
	424
	425	if (!write_to_null)
	426	out_fd = client_open_net(offset);
	427	else
	428	out_fd = open("/dev/null", O_WRONLY);
	429
	430	if (out_fd < 0)
	431	return error("socket");
	432
	433	sprintf(fname, "%s%d", filename, same_file ? 0 : offset);
be35036e	434	file_fd = open(fname, O_RDONLY);
d7b40d65 JA	435	if (file_fd < 0)
	436	return error("open");
	437
be35036e	438	return do_client(out_fd, file_fd, offset);
d7b40d65 JA	439	}
	440
	441	int main(int argc, char *argv[])
	442	{
	443	pid_t spids, cpids;
	444	int i, index;
	445
	446	index = parse_options(argc, argv);
	447	if (index < 0)
	448	return usage(argv[0]);
	449
	450	if (index < argc)
	451	filename = argv[index];
	452
	453	spids = malloc(nr_clients * sizeof(pid_t));
	454	cpids = malloc(nr_clients * sizeof(pid_t));
	455	memset(spids, 0, nr_clients * sizeof(pid_t));
	456	memset(cpids, 0, nr_clients * sizeof(pid_t));
	457
	458	nr_cpus = sysconf(_SC_NPROCESSORS_ONLN);
	459	if (nr_cpus < 0)
	460	return error("_SC_NPROCESSORS_ONLN");
	461
d7b40d65 JA	462	/*
	463	* fork servers
	464	*/
	465	if (!write_to_null) {
	466	for (i = 0; i < nr_clients; i++) {
	467	pid_t pid = fork();
	468
	469	if (pid)
	470	spids[i] = pid;
	471	else {
	472	server(i);
	473	spids[i] = 0;
	474	exit(0);
	475	}
	476	}
	477	sleep(1); /* should have servers started now */
	478	}
	479
	480	/*
	481	* fork clients
	482	*/
	483	for (i = 0; i < nr_clients; i++) {
	484	pid_t pid = fork();
	485
	486	if (pid)
	487	cpids[i] = pid;
	488	else {
	489	client(i);
	490	cpids[i] = 0;
	491	exit(0);
	492	}
	493	}
	494
	495	/*
	496	* wait for clients to exit
	497	*/
	498	fprintf(stdout, "Waiting for clients\n");
	499	for (i = 0; i < nr_clients; i++) {
	500	if (cpids[i]) {
	501	waitpid(cpids[i], NULL, 0);
	502	cpids[i] = 0;
	503	}
	504	}
	505
	506	/*
	507	* then kill servers
	508	*/
	509	for (i = 0; i < nr_clients; i++) {
	510	if (spids[i]) {
	511	kill(spids[i], SIGKILL);
	512	waitpid(spids[i], NULL, 0);
	513	spids[i] = 0;
	514	}
	515	}
	516
	517	return 0;
	518	}