/*
 * gcc -Wall -Werror -O3 -static -o ctx ctx.c
 */

#define errx(x,y...) { fprintf(stderr, y); fprintf(stderr, "\n"); exit(x); }

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/time.h>
#include <signal.h>
#if defined (LWP)
#include <sys/ucontext.h>
#include <sys/lwp.h>
#endif

#define ITERATIONS	8192
#define PASSES		50

int fd0[2], fd1[2];
unsigned long elapsed_times[ITERATIONS];
unsigned long overhead;
pid_t childpid;

static void
usage(void)
{
	printf("ctx [-hl]\n");
	exit(1);
}

static void
child(void)
{
	int ch;

	ch = 0;
	if (write(fd1[1], &ch, 1) != 1)
		errx(1, "child write failed");
	while (1) {
		if (read(fd0[0], &ch, 1) != 1)
			errx(1, "child read failed");
		if (write(fd1[1], &ch, 1) != 1)
			errx(1, "child write failed");
	}
}

static void
dump_results(void)
{
	unsigned long min_time, max_time, sum;
	int i;

	min_time = elapsed_times[0];
	max_time = elapsed_times[0];
	sum = 0;
	for (i=1; i<ITERATIONS; i++) {
		if (elapsed_times[i] < min_time)
			min_time = elapsed_times[i];
		if (elapsed_times[i] > max_time)
			max_time = elapsed_times[i];
		sum += elapsed_times[i] - overhead;
	}
	min_time -= overhead;
	max_time -= overhead;

	printf("min latency: %f\n", (double)min_time / PASSES);
	printf("max latency: %f\n", (double)max_time / PASSES);
	printf("mean latency: %f\n", (double)sum / ITERATIONS / PASSES);
}

int
main(int argc, char *argv[])
{
	int i, ch, count;
	struct timeval before, after;
	unsigned long elapsed;
	int use_lwps = 0;

	memset(elapsed_times, 0, ITERATIONS);

	while ((ch = getopt(argc, argv, "hl")) != -1) {
		switch (ch) {
		case 'l':
#if defined(LWP)
			use_lwps = 1;
#else
			errx(1, "not supported");
#endif
			break;
		case 'h':
			usage();
		}
	}
	argc -= optind;
	argv += optind;

	sleep(1);

	if (pipe(fd0) != 0)
		errx(1, "Unable to create pipe");
	if (pipe(fd1) != 0)
		errx(1, "Unable to create pipe");

	/*
	 * Determine overhead
	 */
	for (count=0; count<2; count++) {
		gettimeofday(&before, NULL);
		for (i=0; i<2*(PASSES/2); i++) {
			ch = 0;
			write(fd0[1], &ch, 1);
			read(fd0[0], &ch, 1);
		}
		gettimeofday(&after, NULL);
		overhead = 1000000 * (after.tv_sec - before.tv_sec);
		overhead += after.tv_usec - before.tv_usec;
	}

	if (use_lwps) {
#if defined(LWP)
		ucontext_t u;
		ucontext_t *contextp;
		int stacksize = 65536;
		void *stackbase;
		lwpid_t l;
		int error;

		getcontext(&u);
		contextp = (ucontext_t *)malloc(sizeof(ucontext_t));
		stackbase = malloc(stacksize);
		sigprocmask(SIG_SETMASK, NULL, &contextp->uc_sigmask);
		_lwp_makecontext(contextp, child, NULL, NULL,
			stackbase, stacksize);
		error = _lwp_create(contextp, 0, &l);
		if (error)
			errx(1, "error _lwp_create");
#endif
	} else {
		switch (childpid = fork()) {
		case 0:		/* child */
			child();
		case -1:	/* error */
			errx(1, "error forking");
			break;
		}
	}

	ch = 0;
	if (read(fd1[0], &ch, 1) != 1)
		errx(1, "parent read failed");
	for (count=0; count<ITERATIONS; count++) {
		gettimeofday(&before, NULL);
		for (i=0; i<PASSES/2; i++) {
			ch = 0;
			if (write(fd0[1], &ch, 1) != 1)
				errx(1, "parent write failed");
			if (read(fd1[0], &ch, 1) != 1)
				errx(1, "parent read failed");
		}
		gettimeofday(&after, NULL);
		elapsed = 1000000 * (after.tv_sec - before.tv_sec);
		elapsed += after.tv_usec - before.tv_usec;
		elapsed_times[count] = elapsed;
	}

	if (!use_lwps)
		kill(childpid, SIGTERM);
	dump_results();

	return (0);
}


/*
 * PMAX_SA:
 *
 * min latency: 93.100000
 * max latency: 150.700000
 * mean latency: 100.857581
 *
 * PMAX_CHOOSEPROC:
 *
 * min latency: 49.350000
 * max latency: 76.750000
 * mean latency: 54.141626
 *
 * PMAX_OLD:
 *
 * min latency: 54.750000
 * max latency: 76.050000
 * mean latency: 60.088654
 *
 * HP300_SA:
 *
 * min latency: 352.560000
 * max latency: 402.960000
 * mean latency: 367.836250
 *
 * HP300_CHOOSEPROC:
 *
 * min latency: 129.200000
 * max latency: 187.040000
 * mean latency: 142.528223
 *
 * HP300_OLD:
 *
 * min latency: 357.360000
 * max latency: 414.400000
 * mean latency: 372.436104
 *
 */