tools/testing/selftests/mqueue/mq_perf_tests.c - kernel/msm-5.4 - Gitiles

 /*
  * This application is Copyright 2012 Red Hat, Inc.
  *	Doug Ledford <dledford@redhat.com>
  *
  * mq_perf_tests is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, version 3.
  *
  * mq_perf_tests is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * For the full text of the license, see <http://www.gnu.org/licenses/>.
  *
  * mq_perf_tests.c
  *   Tests various types of message queue workloads, concentrating on those
  *   situations that invole large message sizes, large message queue depths,
  *   or both, and reports back useful metrics about kernel message queue
  *   performance.
  *
  */
 #define _GNU_SOURCE
 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
 #include <fcntl.h>
 #include <string.h>
 #include <limits.h>
 #include <errno.h>
 #include <signal.h>
 #include <pthread.h>
 #include <sched.h>
 #include <sys/types.h>
 #include <sys/time.h>
 #include <sys/resource.h>
 #include <sys/stat.h>
 #include <mqueue.h>
 #include <popt.h>

 static char *usage =
 "Usage:\n"
 "  %s [-c #[,#..] -f] path\n"
 "\n"
 "	-c #	Skip most tests and go straight to a high queue depth test\n"
 "		and then run that test continuously (useful for running at\n"
 "		the same time as some other workload to see how much the\n"
 "		cache thrashing caused by adding messages to a very deep\n"
 "		queue impacts the performance of other programs).  The number\n"
 "		indicates which CPU core we should bind the process to during\n"
 "		the run.  If you have more than one physical CPU, then you\n"
 "		will need one copy per physical CPU package, and you should\n"
 "		specify the CPU cores to pin ourself to via a comma separated\n"
 "		list of CPU values.\n"
 "	-f	Only usable with continuous mode.  Pin ourself to the CPUs\n"
 "		as requested, then instead of looping doing a high mq\n"
 "		workload, just busy loop.  This will allow us to lock up a\n"
 "		single CPU just like we normally would, but without actually\n"
 "		thrashing the CPU cache.  This is to make it easier to get\n"
 "		comparable numbers from some other workload running on the\n"
 "		other CPUs.  One set of numbers with # CPUs locked up running\n"
 "		an mq workload, and another set of numbers with those same\n"
 "		CPUs locked away from the test workload, but not doing\n"
 "		anything to trash the cache like the mq workload might.\n"
 "	path	Path name of the message queue to create\n"
 "\n"
 "	Note: this program must be run as root in order to enable all tests\n"
 "\n";

 char *MAX_MSGS = "/proc/sys/fs/mqueue/msg_max";
 char *MAX_MSGSIZE = "/proc/sys/fs/mqueue/msgsize_max";

 #define min(a, b) ((a) < (b) ? (a) : (b))
 #define MAX_CPUS 64
 char *cpu_option_string;
 int cpus_to_pin[MAX_CPUS];
 int num_cpus_to_pin;
 pthread_t cpu_threads[MAX_CPUS];
 pthread_t main_thread;
 cpu_set_t *cpu_set;
 int cpu_set_size;
 int cpus_online;

 #define MSG_SIZE 16
 #define TEST1_LOOPS 10000000
 #define TEST2_LOOPS 100000
 int continuous_mode;
 int continuous_mode_fake;

 struct rlimit saved_limits, cur_limits;
 int saved_max_msgs, saved_max_msgsize;
 int cur_max_msgs, cur_max_msgsize;
 FILE *max_msgs, *max_msgsize;
 int cur_nice;
 char *queue_path = "/mq_perf_tests";
 mqd_t queue = -1;
 struct mq_attr result;
 int mq_prio_max;

 const struct poptOption options[] = {
 	{
 		.longName = "continuous",
 		.shortName = 'c',
 		.argInfo = POPT_ARG_STRING,
 		.arg = &cpu_option_string,
 		.val = 'c',
 		.descrip = "Run continuous tests at a high queue depth in "
 			"order to test the effects of cache thrashing on "
 			"other tasks on the system.  This test is intended "
 			"to be run on one core of each physical CPU while "
 			"some other CPU intensive task is run on all the other "
 			"cores of that same physical CPU and the other task "
 			"is timed.  It is assumed that the process of adding "
 			"messages to the message queue in a tight loop will "
 			"impact that other task to some degree.  Once the "
 			"tests are performed in this way, you should then "
 			"re-run the tests using fake mode in order to check "
 			"the difference in time required to perform the CPU "
 			"intensive task",
 		.argDescrip = "cpu[,cpu]",
 	},
 	{
 		.longName = "fake",
 		.shortName = 'f',
 		.argInfo = POPT_ARG_NONE,
 		.arg = &continuous_mode_fake,
 		.val = 0,
 		.descrip = "Tie up the CPUs that we would normally tie up in"
 			"continuous mode, but don't actually do any mq stuff, "
 			"just keep the CPU busy so it can't be used to process "
 			"system level tasks as this would free up resources on "
 			"the other CPU cores and skew the comparison between "
 			"the no-mqueue work and mqueue work tests",
 		.argDescrip = NULL,
 	},
 	{
 		.longName = "path",
 		.shortName = 'p',
 		.argInfo = POPT_ARG_STRING | POPT_ARGFLAG_SHOW_DEFAULT,
 		.arg = &queue_path,
 		.val = 'p',
 		.descrip = "The name of the path to use in the mqueue "
 			"filesystem for our tests",
 		.argDescrip = "pathname",
 	},
 	POPT_AUTOHELP
 	POPT_TABLEEND
 };

 static inline void __set(FILE *stream, int value, char *err_msg);
 void shutdown(int exit_val, char *err_cause, int line_no);
 void sig_action_SIGUSR1(int signum, siginfo_t *info, void *context);
 void sig_action(int signum, siginfo_t *info, void *context);
 static inline int get(FILE *stream);
 static inline void set(FILE *stream, int value);
 static inline int try_set(FILE *stream, int value);
 static inline void getr(int type, struct rlimit *rlim);
 static inline void setr(int type, struct rlimit *rlim);
 static inline void open_queue(struct mq_attr *attr);
 void increase_limits(void);

 static inline void __set(FILE *stream, int value, char *err_msg)
 {
 	rewind(stream);
 	if (fprintf(stream, "%d", value) < 0)
 		perror(err_msg);
 }


 void shutdown(int exit_val, char *err_cause, int line_no)
 {
 	static int in_shutdown = 0;
 	int errno_at_shutdown = errno;
 	int i;

 	/* In case we get called by multiple threads or from an sighandler */
 	if (in_shutdown++)
 		return;

 	for (i = 0; i < num_cpus_to_pin; i++)
 		if (cpu_threads[i]) {
 			pthread_kill(cpu_threads[i], SIGUSR1);
 			pthread_join(cpu_threads[i], NULL);
 		}

 	if (queue != -1)
 		if (mq_close(queue))
 			perror("mq_close() during shutdown");
 	if (queue_path)
 		/*
 		 * Be silent if this fails, if we cleaned up already it's
 		 * expected to fail
 		 */
 		mq_unlink(queue_path);
 	if (saved_max_msgs)
 		__set(max_msgs, saved_max_msgs,
 		      "failed to restore saved_max_msgs");
 	if (saved_max_msgsize)
 		__set(max_msgsize, saved_max_msgsize,
 		      "failed to restore saved_max_msgsize");
 	if (exit_val)
 		error(exit_val, errno_at_shutdown, "%s at %d",
 		      err_cause, line_no);
 	exit(0);
 }

 void sig_action_SIGUSR1(int signum, siginfo_t *info, void *context)
 {
 	if (pthread_self() != main_thread)
 		pthread_exit(0);
 	else {
 		fprintf(stderr, "Caught signal %d in SIGUSR1 handler, "
 				"exiting\n", signum);
 		shutdown(0, "", 0);
 		fprintf(stderr, "\n\nReturned from shutdown?!?!\n\n");
 		exit(0);
 	}
 }

 void sig_action(int signum, siginfo_t *info, void *context)
 {
 	if (pthread_self() != main_thread)
 		pthread_kill(main_thread, signum);
 	else {
 		fprintf(stderr, "Caught signal %d, exiting\n", signum);
 		shutdown(0, "", 0);
 		fprintf(stderr, "\n\nReturned from shutdown?!?!\n\n");
 		exit(0);
 	}
 }

 static inline int get(FILE *stream)
 {
 	int value;
 	rewind(stream);
 	if (fscanf(stream, "%d", &value) != 1)
 		shutdown(4, "Error reading /proc entry", __LINE__);
 	return value;
 }

 static inline void set(FILE *stream, int value)
 {
 	int new_value;

 	rewind(stream);
 	if (fprintf(stream, "%d", value) < 0)
 		return shutdown(5, "Failed writing to /proc file", __LINE__);
 	new_value = get(stream);
 	if (new_value != value)
 		return shutdown(5, "We didn't get what we wrote to /proc back",
 				__LINE__);
 }

 static inline int try_set(FILE *stream, int value)
 {
 	int new_value;

 	rewind(stream);
 	fprintf(stream, "%d", value);
 	new_value = get(stream);
 	return new_value == value;
 }

 static inline void getr(int type, struct rlimit *rlim)
 {
 	if (getrlimit(type, rlim))
 		shutdown(6, "getrlimit()", __LINE__);
 }

 static inline void setr(int type, struct rlimit *rlim)
 {
 	if (setrlimit(type, rlim))
 		shutdown(7, "setrlimit()", __LINE__);
 }

 /**
  * open_queue - open the global queue for testing
  * @attr - An attr struct specifying the desired queue traits
  * @result - An attr struct that lists the actual traits the queue has
  *
  * This open is not allowed to fail, failure will result in an orderly
  * shutdown of the program.  The global queue_path is used to set what
  * queue to open, the queue descriptor is saved in the global queue
  * variable.
  */
 static inline void open_queue(struct mq_attr *attr)
 {
 	int flags = O_RDWR | O_EXCL | O_CREAT | O_NONBLOCK;
 	int perms = DEFFILEMODE;

 	queue = mq_open(queue_path, flags, perms, attr);
 	if (queue == -1)
 		shutdown(1, "mq_open()", __LINE__);
 	if (mq_getattr(queue, &result))
 		shutdown(1, "mq_getattr()", __LINE__);
 	printf("\n\tQueue %s created:\n", queue_path);
 	printf("\t\tmq_flags:\t\t\t%s\n", result.mq_flags & O_NONBLOCK ?
 	       "O_NONBLOCK" : "(null)");
 	printf("\t\tmq_maxmsg:\t\t\t%lu\n", result.mq_maxmsg);
 	printf("\t\tmq_msgsize:\t\t\t%lu\n", result.mq_msgsize);
 	printf("\t\tmq_curmsgs:\t\t\t%lu\n", result.mq_curmsgs);
 }

 void *fake_cont_thread(void *arg)
 {
 	int i;

 	for (i = 0; i < num_cpus_to_pin; i++)
 		if (cpu_threads[i] == pthread_self())
 			break;
 	printf("\tStarted fake continuous mode thread %d on CPU %d\n", i,
 	       cpus_to_pin[i]);
 	while (1)
 		;
 }

 void *cont_thread(void *arg)
 {
 	char buff[MSG_SIZE];
 	int i, priority;

 	for (i = 0; i < num_cpus_to_pin; i++)
 		if (cpu_threads[i] == pthread_self())
 			break;
 	printf("\tStarted continuous mode thread %d on CPU %d\n", i,
 	       cpus_to_pin[i]);
 	while (1) {
 		while (mq_send(queue, buff, sizeof(buff), 0) == 0)
 			;
 		mq_receive(queue, buff, sizeof(buff), &priority);
 	}
 }

 #define drain_queue() \
 	while (mq_receive(queue, buff, MSG_SIZE, &prio_in) == MSG_SIZE)

 #define do_untimed_send() \
 	do { \
 		if (mq_send(queue, buff, MSG_SIZE, prio_out)) \
 			shutdown(3, "Test send failure", __LINE__); \
 	} while (0)

 #define do_send_recv() \
 	do { \
 		clock_gettime(clock, &start); \
 		if (mq_send(queue, buff, MSG_SIZE, prio_out)) \
 			shutdown(3, "Test send failure", __LINE__); \
 		clock_gettime(clock, &middle); \
 		if (mq_receive(queue, buff, MSG_SIZE, &prio_in) != MSG_SIZE) \
 			shutdown(3, "Test receive failure", __LINE__); \
 		clock_gettime(clock, &end); \
 		nsec = ((middle.tv_sec - start.tv_sec) * 1000000000) + \
 			(middle.tv_nsec - start.tv_nsec); \
 		send_total.tv_nsec += nsec; \
 		if (send_total.tv_nsec >= 1000000000) { \
 			send_total.tv_sec++; \
 			send_total.tv_nsec -= 1000000000; \
 		} \
 		nsec = ((end.tv_sec - middle.tv_sec) * 1000000000) + \
 			(end.tv_nsec - middle.tv_nsec); \
 		recv_total.tv_nsec += nsec; \
 		if (recv_total.tv_nsec >= 1000000000) { \
 			recv_total.tv_sec++; \
 			recv_total.tv_nsec -= 1000000000; \
 		} \
 	} while (0)

 struct test {
 	char *desc;
 	void (*func)(int *);
 };

 void const_prio(int *prio)
 {
 	return;
 }

 void inc_prio(int *prio)
 {
 	if (++*prio == mq_prio_max)
 		*prio = 0;
 }

 void dec_prio(int *prio)
 {
 	if (--*prio < 0)
 		*prio = mq_prio_max - 1;
 }

 void random_prio(int *prio)
 {
 	*prio = random() % mq_prio_max;
 }

 struct test test2[] = {
 	{"\n\tTest #2a: Time send/recv message, queue full, constant prio\n",
 		const_prio},
 	{"\n\tTest #2b: Time send/recv message, queue full, increasing prio\n",
 		inc_prio},
 	{"\n\tTest #2c: Time send/recv message, queue full, decreasing prio\n",
 		dec_prio},
 	{"\n\tTest #2d: Time send/recv message, queue full, random prio\n",
 		random_prio},
 	{NULL, NULL}
 };

 /**
  * Tests to perform (all done with MSG_SIZE messages):
  *
  * 1) Time to add/remove message with 0 messages on queue
  * 1a) with constant prio
  * 2) Time to add/remove message when queue close to capacity:
  * 2a) with constant prio
  * 2b) with increasing prio
  * 2c) with decreasing prio
  * 2d) with random prio
  * 3) Test limits of priorities honored (double check _SC_MQ_PRIO_MAX)
  */
 void *perf_test_thread(void *arg)
 {
 	char buff[MSG_SIZE];
 	int prio_out, prio_in;
 	int i;
 	clockid_t clock;
 	pthread_t *t;
 	struct timespec res, start, middle, end, send_total, recv_total;
 	unsigned long long nsec;
 	struct test *cur_test;

 	t = &cpu_threads[0];
 	printf("\n\tStarted mqueue performance test thread on CPU %d\n",
 	       cpus_to_pin[0]);
 	mq_prio_max = sysconf(_SC_MQ_PRIO_MAX);
 	if (mq_prio_max == -1)
 		shutdown(2, "sysconf(_SC_MQ_PRIO_MAX)", __LINE__);
 	if (pthread_getcpuclockid(cpu_threads[0], &clock) != 0)
 		shutdown(2, "pthread_getcpuclockid", __LINE__);

 	if (clock_getres(clock, &res))
 		shutdown(2, "clock_getres()", __LINE__);

 	printf("\t\tMax priorities:\t\t\t%d\n", mq_prio_max);
 	printf("\t\tClock resolution:\t\t%lu nsec%s\n", res.tv_nsec,
 	       res.tv_nsec > 1 ? "s" : "");


 	printf("\n\tTest #1: Time send/recv message, queue empty\n");
 	printf("\t\t(%d iterations)\n", TEST1_LOOPS);
 	prio_out = 0;
 	send_total.tv_sec = 0;
 	send_total.tv_nsec = 0;
 	recv_total.tv_sec = 0;
 	recv_total.tv_nsec = 0;
 	for (i = 0; i < TEST1_LOOPS; i++)
 		do_send_recv();
 	printf("\t\tSend msg:\t\t\t%ld.%lus total time\n",
 	       send_total.tv_sec, send_total.tv_nsec);
 	nsec = ((unsigned long long)send_total.tv_sec * 1000000000 +
 		 send_total.tv_nsec) / TEST1_LOOPS;
 	printf("\t\t\t\t\t\t%lld nsec/msg\n", nsec);
 	printf("\t\tRecv msg:\t\t\t%ld.%lus total time\n",
 	       recv_total.tv_sec, recv_total.tv_nsec);
 	nsec = ((unsigned long long)recv_total.tv_sec * 1000000000 +
 		recv_total.tv_nsec) / TEST1_LOOPS;
 	printf("\t\t\t\t\t\t%lld nsec/msg\n", nsec);


 	for (cur_test = test2; cur_test->desc != NULL; cur_test++) {
 		printf("%s:\n", cur_test->desc);
 		printf("\t\t(%d iterations)\n", TEST2_LOOPS);
 		prio_out = 0;
 		send_total.tv_sec = 0;
 		send_total.tv_nsec = 0;
 		recv_total.tv_sec = 0;
 		recv_total.tv_nsec = 0;
 		printf("\t\tFilling queue...");
 		fflush(stdout);
 		clock_gettime(clock, &start);
 		for (i = 0; i < result.mq_maxmsg - 1; i++) {
 			do_untimed_send();
 			cur_test->func(&prio_out);
 		}
 		clock_gettime(clock, &end);
 		nsec = ((unsigned long long)(end.tv_sec - start.tv_sec) *
 			1000000000) + (end.tv_nsec - start.tv_nsec);
 		printf("done.\t\t%lld.%llds\n", nsec / 1000000000,
 		       nsec % 1000000000);
 		printf("\t\tTesting...");
 		fflush(stdout);
 		for (i = 0; i < TEST2_LOOPS; i++) {
 			do_send_recv();
 			cur_test->func(&prio_out);
 		}
 		printf("done.\n");
 		printf("\t\tSend msg:\t\t\t%ld.%lus total time\n",
 		       send_total.tv_sec, send_total.tv_nsec);
 		nsec = ((unsigned long long)send_total.tv_sec * 1000000000 +
 			 send_total.tv_nsec) / TEST2_LOOPS;
 		printf("\t\t\t\t\t\t%lld nsec/msg\n", nsec);
 		printf("\t\tRecv msg:\t\t\t%ld.%lus total time\n",
 		       recv_total.tv_sec, recv_total.tv_nsec);
 		nsec = ((unsigned long long)recv_total.tv_sec * 1000000000 +
 			recv_total.tv_nsec) / TEST2_LOOPS;
 		printf("\t\t\t\t\t\t%lld nsec/msg\n", nsec);
 		printf("\t\tDraining queue...");
 		fflush(stdout);
 		clock_gettime(clock, &start);
 		drain_queue();
 		clock_gettime(clock, &end);
 		nsec = ((unsigned long long)(end.tv_sec - start.tv_sec) *
 			1000000000) + (end.tv_nsec - start.tv_nsec);
 		printf("done.\t\t%lld.%llds\n", nsec / 1000000000,
 		       nsec % 1000000000);
 	}
 	return 0;
 }

 void increase_limits(void)
 {
 	cur_limits.rlim_cur = RLIM_INFINITY;
 	cur_limits.rlim_max = RLIM_INFINITY;
 	setr(RLIMIT_MSGQUEUE, &cur_limits);
 	while (try_set(max_msgs, cur_max_msgs += 10))
 		;
 	cur_max_msgs = get(max_msgs);
 	while (try_set(max_msgsize, cur_max_msgsize += 1024))
 		;
 	cur_max_msgsize = get(max_msgsize);
 	if (setpriority(PRIO_PROCESS, 0, -20) != 0)
 		shutdown(2, "setpriority()", __LINE__);
 	cur_nice = -20;
 }

 int main(int argc, char *argv[])
 {
 	struct mq_attr attr;
 	char *option, *next_option;
 	int i, cpu;
 	struct sigaction sa;
 	poptContext popt_context;
 	char rc;
 	void *retval;

 	main_thread = pthread_self();
 	num_cpus_to_pin = 0;

 	if (sysconf(_SC_NPROCESSORS_ONLN) == -1) {
 		perror("sysconf(_SC_NPROCESSORS_ONLN)");
 		exit(1);
 	}
 	cpus_online = min(MAX_CPUS, sysconf(_SC_NPROCESSORS_ONLN));
 	cpu_set = CPU_ALLOC(cpus_online);
 	if (cpu_set == NULL) {
 		perror("CPU_ALLOC()");
 		exit(1);
 	}
 	cpu_set_size = CPU_ALLOC_SIZE(cpus_online);
 	CPU_ZERO_S(cpu_set_size, cpu_set);

 	popt_context = poptGetContext(NULL, argc, (const char **)argv,
 				      options, 0);

 	while ((rc = poptGetNextOpt(popt_context)) > 0) {
 		switch (rc) {
 		case 'c':
 			continuous_mode = 1;
 			option = cpu_option_string;
 			do {
 				next_option = strchr(option, ',');
 				if (next_option)
 					*next_option = '\0';
 				cpu = atoi(option);
 				if (cpu >= cpus_online)
 					fprintf(stderr, "CPU %d exceeds "
 						"cpus online, ignoring.\n",
 						cpu);
 				else
 					cpus_to_pin[num_cpus_to_pin++] = cpu;
 				if (next_option)
 					option = ++next_option;
 			} while (next_option && num_cpus_to_pin < MAX_CPUS);
 			/* Double check that they didn't give us the same CPU
 			 * more than once */
 			for (cpu = 0; cpu < num_cpus_to_pin; cpu++) {
 				if (CPU_ISSET_S(cpus_to_pin[cpu], cpu_set_size,
 						cpu_set)) {
 					fprintf(stderr, "Any given CPU may "
 						"only be given once.\n");
 					exit(1);
 				} else
 					CPU_SET_S(cpus_to_pin[cpu],
 						  cpu_set_size, cpu_set);
 			}
 			break;
 		case 'p':
 			/*
 			 * Although we can create a msg queue with a
 			 * non-absolute path name, unlink will fail.  So,
 			 * if the name doesn't start with a /, add one
 			 * when we save it.
 			 */
 			option = queue_path;
 			if (*option != '/') {
 				queue_path = malloc(strlen(option) + 2);
 				if (!queue_path) {
 					perror("malloc()");
 					exit(1);
 				}
 				queue_path[0] = '/';
 				queue_path[1] = 0;
 				strcat(queue_path, option);
 				free(option);
 			}
 			break;
 		}
 	}

 	if (continuous_mode && num_cpus_to_pin == 0) {
 		fprintf(stderr, "Must pass at least one CPU to continuous "
 			"mode.\n");
 		poptPrintUsage(popt_context, stderr, 0);
 		exit(1);
 	} else if (!continuous_mode) {
 		num_cpus_to_pin = 1;
 		cpus_to_pin[0] = cpus_online - 1;
 	}

 	if (getuid() != 0) {
 		fprintf(stderr, "Not running as root, but almost all tests "
 			"require root in order to modify\nsystem settings.  "
 			"Exiting.\n");
 		exit(1);
 	}

 	max_msgs = fopen(MAX_MSGS, "r+");
 	max_msgsize = fopen(MAX_MSGSIZE, "r+");
 	if (!max_msgs)
 		shutdown(2, "Failed to open msg_max", __LINE__);
 	if (!max_msgsize)
 		shutdown(2, "Failed to open msgsize_max", __LINE__);

 	/* Load up the current system values for everything we can */
 	getr(RLIMIT_MSGQUEUE, &saved_limits);
 	cur_limits = saved_limits;
 	saved_max_msgs = cur_max_msgs = get(max_msgs);
 	saved_max_msgsize = cur_max_msgsize = get(max_msgsize);
 	errno = 0;
 	cur_nice = getpriority(PRIO_PROCESS, 0);
 	if (errno)
 		shutdown(2, "getpriority()", __LINE__);

 	/* Tell the user our initial state */
 	printf("\nInitial system state:\n");
 	printf("\tUsing queue path:\t\t\t%s\n", queue_path);
 	printf("\tRLIMIT_MSGQUEUE(soft):\t\t\t%ld\n",
 		(long) saved_limits.rlim_cur);
 	printf("\tRLIMIT_MSGQUEUE(hard):\t\t\t%ld\n",
 		(long) saved_limits.rlim_max);
 	printf("\tMaximum Message Size:\t\t\t%d\n", saved_max_msgsize);
 	printf("\tMaximum Queue Size:\t\t\t%d\n", saved_max_msgs);
 	printf("\tNice value:\t\t\t\t%d\n", cur_nice);
 	printf("\n");

 	increase_limits();

 	printf("Adjusted system state for testing:\n");
 	if (cur_limits.rlim_cur == RLIM_INFINITY) {
 		printf("\tRLIMIT_MSGQUEUE(soft):\t\t\t(unlimited)\n");
 		printf("\tRLIMIT_MSGQUEUE(hard):\t\t\t(unlimited)\n");
 	} else {
 		printf("\tRLIMIT_MSGQUEUE(soft):\t\t\t%ld\n",
 		       (long) cur_limits.rlim_cur);
 		printf("\tRLIMIT_MSGQUEUE(hard):\t\t\t%ld\n",
 		       (long) cur_limits.rlim_max);
 	}
 	printf("\tMaximum Message Size:\t\t\t%d\n", cur_max_msgsize);
 	printf("\tMaximum Queue Size:\t\t\t%d\n", cur_max_msgs);
 	printf("\tNice value:\t\t\t\t%d\n", cur_nice);
 	printf("\tContinuous mode:\t\t\t(%s)\n", continuous_mode ?
 	       (continuous_mode_fake ? "fake mode" : "enabled") :
 	       "disabled");
 	printf("\tCPUs to pin:\t\t\t\t%d", cpus_to_pin[0]);
 	for (cpu = 1; cpu < num_cpus_to_pin; cpu++)
 			printf(",%d", cpus_to_pin[cpu]);
 	printf("\n");

 	sa.sa_sigaction = sig_action_SIGUSR1;
 	sigemptyset(&sa.sa_mask);
 	sigaddset(&sa.sa_mask, SIGHUP);
 	sigaddset(&sa.sa_mask, SIGINT);
 	sigaddset(&sa.sa_mask, SIGQUIT);
 	sigaddset(&sa.sa_mask, SIGTERM);
 	sa.sa_flags = SA_SIGINFO;
 	if (sigaction(SIGUSR1, &sa, NULL) == -1)
 		shutdown(1, "sigaction(SIGUSR1)", __LINE__);
 	sa.sa_sigaction = sig_action;
 	if (sigaction(SIGHUP, &sa, NULL) == -1)
 		shutdown(1, "sigaction(SIGHUP)", __LINE__);
 	if (sigaction(SIGINT, &sa, NULL) == -1)
 		shutdown(1, "sigaction(SIGINT)", __LINE__);
 	if (sigaction(SIGQUIT, &sa, NULL) == -1)
 		shutdown(1, "sigaction(SIGQUIT)", __LINE__);
 	if (sigaction(SIGTERM, &sa, NULL) == -1)
 		shutdown(1, "sigaction(SIGTERM)", __LINE__);

 	if (!continuous_mode_fake) {
 		attr.mq_flags = O_NONBLOCK;
 		attr.mq_maxmsg = cur_max_msgs;
 		attr.mq_msgsize = MSG_SIZE;
 		open_queue(&attr);
 	}
 	for (i = 0; i < num_cpus_to_pin; i++) {
 		pthread_attr_t thread_attr;
 		void *thread_func;

 		if (continuous_mode_fake)
 			thread_func = &fake_cont_thread;
 		else if (continuous_mode)
 			thread_func = &cont_thread;
 		else
 			thread_func = &perf_test_thread;

 		CPU_ZERO_S(cpu_set_size, cpu_set);
 		CPU_SET_S(cpus_to_pin[i], cpu_set_size, cpu_set);
 		pthread_attr_init(&thread_attr);
 		pthread_attr_setaffinity_np(&thread_attr, cpu_set_size,
 					    cpu_set);
 		if (pthread_create(&cpu_threads[i], &thread_attr, thread_func,
 				   NULL))
 			shutdown(1, "pthread_create()", __LINE__);
 		pthread_attr_destroy(&thread_attr);
 	}

 	if (!continuous_mode) {
 		pthread_join(cpu_threads[0], &retval);
 		shutdown((long)retval, "perf_test_thread()", __LINE__);
 	} else {
 		while (1)
 			sleep(1);
 	}
 	shutdown(0, "", 0);
 }
	/*
	* This application is Copyright 2012 Red Hat, Inc.
	* Doug Ledford <dledford@redhat.com>
	*
	* mq_perf_tests is free software: you can redistribute it and/or modify
	* it under the terms of the GNU General Public License as published by
	* the Free Software Foundation, version 3.
	*
	* mq_perf_tests is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* For the full text of the license, see <http://www.gnu.org/licenses/>.
	*
	* mq_perf_tests.c
	* Tests various types of message queue workloads, concentrating on those
	* situations that invole large message sizes, large message queue depths,
	* or both, and reports back useful metrics about kernel message queue
	* performance.
	*
	*/
	#define _GNU_SOURCE
	#include <stdio.h>
	#include <stdlib.h>
	#include <unistd.h>
	#include <fcntl.h>
	#include <string.h>
	#include <limits.h>
	#include <errno.h>
	#include <signal.h>
	#include <pthread.h>
	#include <sched.h>
	#include <sys/types.h>
	#include <sys/time.h>
	#include <sys/resource.h>
	#include <sys/stat.h>
	#include <mqueue.h>
	#include <popt.h>

	static char *usage =
	"Usage:\n"
	" %s [-c #[,#..] -f] path\n"
	"\n"
	" -c # Skip most tests and go straight to a high queue depth test\n"
	" and then run that test continuously (useful for running at\n"
	" the same time as some other workload to see how much the\n"
	" cache thrashing caused by adding messages to a very deep\n"
	" queue impacts the performance of other programs). The number\n"
	" indicates which CPU core we should bind the process to during\n"
	" the run. If you have more than one physical CPU, then you\n"
	" will need one copy per physical CPU package, and you should\n"
	" specify the CPU cores to pin ourself to via a comma separated\n"
	" list of CPU values.\n"
	" -f Only usable with continuous mode. Pin ourself to the CPUs\n"
	" as requested, then instead of looping doing a high mq\n"
	" workload, just busy loop. This will allow us to lock up a\n"
	" single CPU just like we normally would, but without actually\n"
	" thrashing the CPU cache. This is to make it easier to get\n"
	" comparable numbers from some other workload running on the\n"
	" other CPUs. One set of numbers with # CPUs locked up running\n"
	" an mq workload, and another set of numbers with those same\n"
	" CPUs locked away from the test workload, but not doing\n"
	" anything to trash the cache like the mq workload might.\n"
	" path Path name of the message queue to create\n"
	"\n"
	" Note: this program must be run as root in order to enable all tests\n"
	"\n";

	char *MAX_MSGS = "/proc/sys/fs/mqueue/msg_max";
	char *MAX_MSGSIZE = "/proc/sys/fs/mqueue/msgsize_max";

	#define min(a, b) ((a) < (b) ? (a) : (b))
	#define MAX_CPUS 64
	char *cpu_option_string;
	int cpus_to_pin[MAX_CPUS];
	int num_cpus_to_pin;
	pthread_t cpu_threads[MAX_CPUS];
	pthread_t main_thread;
	cpu_set_t *cpu_set;
	int cpu_set_size;
	int cpus_online;

	#define MSG_SIZE 16
	#define TEST1_LOOPS 10000000
	#define TEST2_LOOPS 100000
	int continuous_mode;
	int continuous_mode_fake;

	struct rlimit saved_limits, cur_limits;
	int saved_max_msgs, saved_max_msgsize;
	int cur_max_msgs, cur_max_msgsize;
	FILE max_msgs, max_msgsize;
	int cur_nice;
	char *queue_path = "/mq_perf_tests";
	mqd_t queue = -1;
	struct mq_attr result;
	int mq_prio_max;

	const struct poptOption options[] = {
	{
	.longName = "continuous",
	.shortName = 'c',
	.argInfo = POPT_ARG_STRING,
	.arg = &cpu_option_string,
	.val = 'c',
	.descrip = "Run continuous tests at a high queue depth in "
	"order to test the effects of cache thrashing on "
	"other tasks on the system. This test is intended "
	"to be run on one core of each physical CPU while "
	"some other CPU intensive task is run on all the other "
	"cores of that same physical CPU and the other task "
	"is timed. It is assumed that the process of adding "
	"messages to the message queue in a tight loop will "
	"impact that other task to some degree. Once the "
	"tests are performed in this way, you should then "
	"re-run the tests using fake mode in order to check "
	"the difference in time required to perform the CPU "
	"intensive task",
	.argDescrip = "cpu[,cpu]",
	},
	{
	.longName = "fake",
	.shortName = 'f',
	.argInfo = POPT_ARG_NONE,
	.arg = &continuous_mode_fake,
	.val = 0,
	.descrip = "Tie up the CPUs that we would normally tie up in"
	"continuous mode, but don't actually do any mq stuff, "
	"just keep the CPU busy so it can't be used to process "
	"system level tasks as this would free up resources on "
	"the other CPU cores and skew the comparison between "
	"the no-mqueue work and mqueue work tests",
	.argDescrip = NULL,
	},
	{
	.longName = "path",
	.shortName = 'p',
	.argInfo = POPT_ARG_STRING \| POPT_ARGFLAG_SHOW_DEFAULT,
	.arg = &queue_path,
	.val = 'p',
	.descrip = "The name of the path to use in the mqueue "
	"filesystem for our tests",
	.argDescrip = "pathname",
	},
	POPT_AUTOHELP
	POPT_TABLEEND
	};

	static inline void __set(FILE stream, int value, char err_msg);
	void shutdown(int exit_val, char *err_cause, int line_no);
	void sig_action_SIGUSR1(int signum, siginfo_t info, void context);
	void sig_action(int signum, siginfo_t info, void context);
	static inline int get(FILE *stream);
	static inline void set(FILE *stream, int value);
	static inline int try_set(FILE *stream, int value);
	static inline void getr(int type, struct rlimit *rlim);
	static inline void setr(int type, struct rlimit *rlim);
	static inline void open_queue(struct mq_attr *attr);
	void increase_limits(void);

	static inline void __set(FILE stream, int value, char err_msg)
	{
	rewind(stream);
	if (fprintf(stream, "%d", value) < 0)
	perror(err_msg);
	}


	void shutdown(int exit_val, char *err_cause, int line_no)
	{
	static int in_shutdown = 0;
	int errno_at_shutdown = errno;
	int i;

	/* In case we get called by multiple threads or from an sighandler */
	if (in_shutdown++)
	return;

	for (i = 0; i < num_cpus_to_pin; i++)
	if (cpu_threads[i]) {
	pthread_kill(cpu_threads[i], SIGUSR1);
	pthread_join(cpu_threads[i], NULL);
	}

	if (queue != -1)
	if (mq_close(queue))
	perror("mq_close() during shutdown");
	if (queue_path)
	/*
	* Be silent if this fails, if we cleaned up already it's
	* expected to fail
	*/
	mq_unlink(queue_path);
	if (saved_max_msgs)
	__set(max_msgs, saved_max_msgs,
	"failed to restore saved_max_msgs");
	if (saved_max_msgsize)
	__set(max_msgsize, saved_max_msgsize,
	"failed to restore saved_max_msgsize");
	if (exit_val)
	error(exit_val, errno_at_shutdown, "%s at %d",
	err_cause, line_no);
	exit(0);
	}

	void sig_action_SIGUSR1(int signum, siginfo_t info, void context)
	{
	if (pthread_self() != main_thread)
	pthread_exit(0);
	else {
	fprintf(stderr, "Caught signal %d in SIGUSR1 handler, "
	"exiting\n", signum);
	shutdown(0, "", 0);
	fprintf(stderr, "\n\nReturned from shutdown?!?!\n\n");
	exit(0);
	}
	}

	void sig_action(int signum, siginfo_t info, void context)
	{
	if (pthread_self() != main_thread)
	pthread_kill(main_thread, signum);
	else {
	fprintf(stderr, "Caught signal %d, exiting\n", signum);
	shutdown(0, "", 0);
	fprintf(stderr, "\n\nReturned from shutdown?!?!\n\n");
	exit(0);
	}
	}

	static inline int get(FILE *stream)
	{
	int value;
	rewind(stream);
	if (fscanf(stream, "%d", &value) != 1)
	shutdown(4, "Error reading /proc entry", __LINE__);
	return value;
	}

	static inline void set(FILE *stream, int value)
	{
	int new_value;

	rewind(stream);
	if (fprintf(stream, "%d", value) < 0)
	return shutdown(5, "Failed writing to /proc file", __LINE__);
	new_value = get(stream);
	if (new_value != value)
	return shutdown(5, "We didn't get what we wrote to /proc back",
	__LINE__);
	}

	static inline int try_set(FILE *stream, int value)
	{
	int new_value;

	rewind(stream);
	fprintf(stream, "%d", value);
	new_value = get(stream);
	return new_value == value;
	}

	static inline void getr(int type, struct rlimit *rlim)
	{
	if (getrlimit(type, rlim))
	shutdown(6, "getrlimit()", __LINE__);
	}

	static inline void setr(int type, struct rlimit *rlim)
	{
	if (setrlimit(type, rlim))
	shutdown(7, "setrlimit()", __LINE__);
	}

	/**
	* open_queue - open the global queue for testing
	* @attr - An attr struct specifying the desired queue traits
	* @result - An attr struct that lists the actual traits the queue has
	*
	* This open is not allowed to fail, failure will result in an orderly
	* shutdown of the program. The global queue_path is used to set what
	* queue to open, the queue descriptor is saved in the global queue
	* variable.
	*/
	static inline void open_queue(struct mq_attr *attr)
	{
	int flags = O_RDWR \| O_EXCL \| O_CREAT \| O_NONBLOCK;
	int perms = DEFFILEMODE;

	queue = mq_open(queue_path, flags, perms, attr);
	if (queue == -1)
	shutdown(1, "mq_open()", __LINE__);
	if (mq_getattr(queue, &result))
	shutdown(1, "mq_getattr()", __LINE__);
	printf("\n\tQueue %s created:\n", queue_path);
	printf("\t\tmq_flags:\t\t\t%s\n", result.mq_flags & O_NONBLOCK ?
	"O_NONBLOCK" : "(null)");
	printf("\t\tmq_maxmsg:\t\t\t%lu\n", result.mq_maxmsg);
	printf("\t\tmq_msgsize:\t\t\t%lu\n", result.mq_msgsize);
	printf("\t\tmq_curmsgs:\t\t\t%lu\n", result.mq_curmsgs);
	}

	void fake_cont_thread(void arg)
	{
	int i;

	for (i = 0; i < num_cpus_to_pin; i++)
	if (cpu_threads[i] == pthread_self())
	break;
	printf("\tStarted fake continuous mode thread %d on CPU %d\n", i,
	cpus_to_pin[i]);
	while (1)
	;
	}

	void cont_thread(void arg)
	{
	char buff[MSG_SIZE];
	int i, priority;

	for (i = 0; i < num_cpus_to_pin; i++)
	if (cpu_threads[i] == pthread_self())
	break;
	printf("\tStarted continuous mode thread %d on CPU %d\n", i,
	cpus_to_pin[i]);
	while (1) {
	while (mq_send(queue, buff, sizeof(buff), 0) == 0)
	;
	mq_receive(queue, buff, sizeof(buff), &priority);
	}
	}

	#define drain_queue() \
	while (mq_receive(queue, buff, MSG_SIZE, &prio_in) == MSG_SIZE)

	#define do_untimed_send() \
	do { \
	if (mq_send(queue, buff, MSG_SIZE, prio_out)) \
	shutdown(3, "Test send failure", __LINE__); \
	} while (0)

	#define do_send_recv() \
	do { \
	clock_gettime(clock, &start); \
	if (mq_send(queue, buff, MSG_SIZE, prio_out)) \
	shutdown(3, "Test send failure", __LINE__); \
	clock_gettime(clock, &middle); \
	if (mq_receive(queue, buff, MSG_SIZE, &prio_in) != MSG_SIZE) \
	shutdown(3, "Test receive failure", __LINE__); \
	clock_gettime(clock, &end); \
	nsec = ((middle.tv_sec - start.tv_sec) * 1000000000) + \
	(middle.tv_nsec - start.tv_nsec); \
	send_total.tv_nsec += nsec; \
	if (send_total.tv_nsec >= 1000000000) { \
	send_total.tv_sec++; \
	send_total.tv_nsec -= 1000000000; \
	} \
	nsec = ((end.tv_sec - middle.tv_sec) * 1000000000) + \
	(end.tv_nsec - middle.tv_nsec); \
	recv_total.tv_nsec += nsec; \
	if (recv_total.tv_nsec >= 1000000000) { \
	recv_total.tv_sec++; \
	recv_total.tv_nsec -= 1000000000; \
	} \
	} while (0)

	struct test {
	char *desc;
	void (func)(int );
	};

	void const_prio(int *prio)
	{
	return;
	}

	void inc_prio(int *prio)
	{
	if (++*prio == mq_prio_max)
	*prio = 0;
	}

	void dec_prio(int *prio)
	{
	if (--*prio < 0)
	*prio = mq_prio_max - 1;
	}

	void random_prio(int *prio)
	{
	*prio = random() % mq_prio_max;
	}

	struct test test2[] = {
	{"\n\tTest #2a: Time send/recv message, queue full, constant prio\n",
	const_prio},
	{"\n\tTest #2b: Time send/recv message, queue full, increasing prio\n",
	inc_prio},
	{"\n\tTest #2c: Time send/recv message, queue full, decreasing prio\n",
	dec_prio},
	{"\n\tTest #2d: Time send/recv message, queue full, random prio\n",
	random_prio},
	{NULL, NULL}
	};

	/**
	* Tests to perform (all done with MSG_SIZE messages):
	*
	* 1) Time to add/remove message with 0 messages on queue
	* 1a) with constant prio
	* 2) Time to add/remove message when queue close to capacity:
	* 2a) with constant prio
	* 2b) with increasing prio
	* 2c) with decreasing prio
	* 2d) with random prio
	* 3) Test limits of priorities honored (double check _SC_MQ_PRIO_MAX)
	*/
	void perf_test_thread(void arg)
	{
	char buff[MSG_SIZE];
	int prio_out, prio_in;
	int i;
	clockid_t clock;
	pthread_t *t;
	struct timespec res, start, middle, end, send_total, recv_total;
	unsigned long long nsec;
	struct test *cur_test;

	t = &cpu_threads[0];
	printf("\n\tStarted mqueue performance test thread on CPU %d\n",
	cpus_to_pin[0]);
	mq_prio_max = sysconf(_SC_MQ_PRIO_MAX);
	if (mq_prio_max == -1)
	shutdown(2, "sysconf(_SC_MQ_PRIO_MAX)", __LINE__);
	if (pthread_getcpuclockid(cpu_threads[0], &clock) != 0)
	shutdown(2, "pthread_getcpuclockid", __LINE__);

	if (clock_getres(clock, &res))
	shutdown(2, "clock_getres()", __LINE__);

	printf("\t\tMax priorities:\t\t\t%d\n", mq_prio_max);
	printf("\t\tClock resolution:\t\t%lu nsec%s\n", res.tv_nsec,
	res.tv_nsec > 1 ? "s" : "");



	printf("\n\tTest #1: Time send/recv message, queue empty\n");
	printf("\t\t(%d iterations)\n", TEST1_LOOPS);
	prio_out = 0;
	send_total.tv_sec = 0;
	send_total.tv_nsec = 0;
	recv_total.tv_sec = 0;
	recv_total.tv_nsec = 0;
	for (i = 0; i < TEST1_LOOPS; i++)
	do_send_recv();
	printf("\t\tSend msg:\t\t\t%ld.%lus total time\n",
	send_total.tv_sec, send_total.tv_nsec);
	nsec = ((unsigned long long)send_total.tv_sec * 1000000000 +
	send_total.tv_nsec) / TEST1_LOOPS;
	printf("\t\t\t\t\t\t%lld nsec/msg\n", nsec);
	printf("\t\tRecv msg:\t\t\t%ld.%lus total time\n",
	recv_total.tv_sec, recv_total.tv_nsec);
	nsec = ((unsigned long long)recv_total.tv_sec * 1000000000 +
	recv_total.tv_nsec) / TEST1_LOOPS;
	printf("\t\t\t\t\t\t%lld nsec/msg\n", nsec);


	for (cur_test = test2; cur_test->desc != NULL; cur_test++) {
	printf("%s:\n", cur_test->desc);
	printf("\t\t(%d iterations)\n", TEST2_LOOPS);
	prio_out = 0;
	send_total.tv_sec = 0;
	send_total.tv_nsec = 0;
	recv_total.tv_sec = 0;
	recv_total.tv_nsec = 0;
	printf("\t\tFilling queue...");
	fflush(stdout);
	clock_gettime(clock, &start);
	for (i = 0; i < result.mq_maxmsg - 1; i++) {
	do_untimed_send();
	cur_test->func(&prio_out);
	}
	clock_gettime(clock, &end);
	nsec = ((unsigned long long)(end.tv_sec - start.tv_sec) *
	1000000000) + (end.tv_nsec - start.tv_nsec);
	printf("done.\t\t%lld.%llds\n", nsec / 1000000000,
	nsec % 1000000000);
	printf("\t\tTesting...");
	fflush(stdout);
	for (i = 0; i < TEST2_LOOPS; i++) {
	do_send_recv();
	cur_test->func(&prio_out);
	}
	printf("done.\n");
	printf("\t\tSend msg:\t\t\t%ld.%lus total time\n",
	send_total.tv_sec, send_total.tv_nsec);
	nsec = ((unsigned long long)send_total.tv_sec * 1000000000 +
	send_total.tv_nsec) / TEST2_LOOPS;
	printf("\t\t\t\t\t\t%lld nsec/msg\n", nsec);
	printf("\t\tRecv msg:\t\t\t%ld.%lus total time\n",
	recv_total.tv_sec, recv_total.tv_nsec);
	nsec = ((unsigned long long)recv_total.tv_sec * 1000000000 +
	recv_total.tv_nsec) / TEST2_LOOPS;
	printf("\t\t\t\t\t\t%lld nsec/msg\n", nsec);
	printf("\t\tDraining queue...");
	fflush(stdout);
	clock_gettime(clock, &start);
	drain_queue();
	clock_gettime(clock, &end);
	nsec = ((unsigned long long)(end.tv_sec - start.tv_sec) *
	1000000000) + (end.tv_nsec - start.tv_nsec);
	printf("done.\t\t%lld.%llds\n", nsec / 1000000000,
	nsec % 1000000000);
	}
	return 0;
	}

	void increase_limits(void)
	{
	cur_limits.rlim_cur = RLIM_INFINITY;
	cur_limits.rlim_max = RLIM_INFINITY;
	setr(RLIMIT_MSGQUEUE, &cur_limits);
	while (try_set(max_msgs, cur_max_msgs += 10))
	;
	cur_max_msgs = get(max_msgs);
	while (try_set(max_msgsize, cur_max_msgsize += 1024))
	;
	cur_max_msgsize = get(max_msgsize);
	if (setpriority(PRIO_PROCESS, 0, -20) != 0)
	shutdown(2, "setpriority()", __LINE__);
	cur_nice = -20;
	}

	int main(int argc, char *argv[])
	{
	struct mq_attr attr;
	char option, next_option;
	int i, cpu;
	struct sigaction sa;
	poptContext popt_context;
	char rc;
	void *retval;

	main_thread = pthread_self();
	num_cpus_to_pin = 0;

	if (sysconf(_SC_NPROCESSORS_ONLN) == -1) {
	perror("sysconf(_SC_NPROCESSORS_ONLN)");
	exit(1);
	}
	cpus_online = min(MAX_CPUS, sysconf(_SC_NPROCESSORS_ONLN));
	cpu_set = CPU_ALLOC(cpus_online);
	if (cpu_set == NULL) {
	perror("CPU_ALLOC()");
	exit(1);
	}
	cpu_set_size = CPU_ALLOC_SIZE(cpus_online);
	CPU_ZERO_S(cpu_set_size, cpu_set);

	popt_context = poptGetContext(NULL, argc, (const char **)argv,
	options, 0);

	while ((rc = poptGetNextOpt(popt_context)) > 0) {
	switch (rc) {
	case 'c':
	continuous_mode = 1;
	option = cpu_option_string;
	do {
	next_option = strchr(option, ',');
	if (next_option)
	*next_option = '\0';
	cpu = atoi(option);
	if (cpu >= cpus_online)
	fprintf(stderr, "CPU %d exceeds "
	"cpus online, ignoring.\n",
	cpu);
	else
	cpus_to_pin[num_cpus_to_pin++] = cpu;
	if (next_option)
	option = ++next_option;
	} while (next_option && num_cpus_to_pin < MAX_CPUS);
	/* Double check that they didn't give us the same CPU
	* more than once */
	for (cpu = 0; cpu < num_cpus_to_pin; cpu++) {
	if (CPU_ISSET_S(cpus_to_pin[cpu], cpu_set_size,
	cpu_set)) {
	fprintf(stderr, "Any given CPU may "
	"only be given once.\n");
	exit(1);
	} else
	CPU_SET_S(cpus_to_pin[cpu],
	cpu_set_size, cpu_set);
	}
	break;
	case 'p':
	/*
	* Although we can create a msg queue with a
	* non-absolute path name, unlink will fail. So,
	* if the name doesn't start with a /, add one
	* when we save it.
	*/
	option = queue_path;
	if (*option != '/') {
	queue_path = malloc(strlen(option) + 2);
	if (!queue_path) {
	perror("malloc()");
	exit(1);
	}
	queue_path[0] = '/';
	queue_path[1] = 0;
	strcat(queue_path, option);
	free(option);
	}
	break;
	}
	}

	if (continuous_mode && num_cpus_to_pin == 0) {
	fprintf(stderr, "Must pass at least one CPU to continuous "
	"mode.\n");
	poptPrintUsage(popt_context, stderr, 0);
	exit(1);
	} else if (!continuous_mode) {
	num_cpus_to_pin = 1;
	cpus_to_pin[0] = cpus_online - 1;
	}

	if (getuid() != 0) {
	fprintf(stderr, "Not running as root, but almost all tests "
	"require root in order to modify\nsystem settings. "
	"Exiting.\n");
	exit(1);
	}

	max_msgs = fopen(MAX_MSGS, "r+");
	max_msgsize = fopen(MAX_MSGSIZE, "r+");
	if (!max_msgs)
	shutdown(2, "Failed to open msg_max", __LINE__);
	if (!max_msgsize)
	shutdown(2, "Failed to open msgsize_max", __LINE__);

	/* Load up the current system values for everything we can */
	getr(RLIMIT_MSGQUEUE, &saved_limits);
	cur_limits = saved_limits;
	saved_max_msgs = cur_max_msgs = get(max_msgs);
	saved_max_msgsize = cur_max_msgsize = get(max_msgsize);
	errno = 0;
	cur_nice = getpriority(PRIO_PROCESS, 0);
	if (errno)
	shutdown(2, "getpriority()", __LINE__);

	/* Tell the user our initial state */
	printf("\nInitial system state:\n");
	printf("\tUsing queue path:\t\t\t%s\n", queue_path);
	printf("\tRLIMIT_MSGQUEUE(soft):\t\t\t%ld\n",
	(long) saved_limits.rlim_cur);
	printf("\tRLIMIT_MSGQUEUE(hard):\t\t\t%ld\n",
	(long) saved_limits.rlim_max);
	printf("\tMaximum Message Size:\t\t\t%d\n", saved_max_msgsize);
	printf("\tMaximum Queue Size:\t\t\t%d\n", saved_max_msgs);
	printf("\tNice value:\t\t\t\t%d\n", cur_nice);
	printf("\n");

	increase_limits();

	printf("Adjusted system state for testing:\n");
	if (cur_limits.rlim_cur == RLIM_INFINITY) {
	printf("\tRLIMIT_MSGQUEUE(soft):\t\t\t(unlimited)\n");
	printf("\tRLIMIT_MSGQUEUE(hard):\t\t\t(unlimited)\n");
	} else {
	printf("\tRLIMIT_MSGQUEUE(soft):\t\t\t%ld\n",
	(long) cur_limits.rlim_cur);
	printf("\tRLIMIT_MSGQUEUE(hard):\t\t\t%ld\n",
	(long) cur_limits.rlim_max);
	}
	printf("\tMaximum Message Size:\t\t\t%d\n", cur_max_msgsize);
	printf("\tMaximum Queue Size:\t\t\t%d\n", cur_max_msgs);
	printf("\tNice value:\t\t\t\t%d\n", cur_nice);
	printf("\tContinuous mode:\t\t\t(%s)\n", continuous_mode ?
	(continuous_mode_fake ? "fake mode" : "enabled") :
	"disabled");
	printf("\tCPUs to pin:\t\t\t\t%d", cpus_to_pin[0]);
	for (cpu = 1; cpu < num_cpus_to_pin; cpu++)
	printf(",%d", cpus_to_pin[cpu]);
	printf("\n");

	sa.sa_sigaction = sig_action_SIGUSR1;
	sigemptyset(&sa.sa_mask);
	sigaddset(&sa.sa_mask, SIGHUP);
	sigaddset(&sa.sa_mask, SIGINT);
	sigaddset(&sa.sa_mask, SIGQUIT);
	sigaddset(&sa.sa_mask, SIGTERM);
	sa.sa_flags = SA_SIGINFO;
	if (sigaction(SIGUSR1, &sa, NULL) == -1)
	shutdown(1, "sigaction(SIGUSR1)", __LINE__);
	sa.sa_sigaction = sig_action;
	if (sigaction(SIGHUP, &sa, NULL) == -1)
	shutdown(1, "sigaction(SIGHUP)", __LINE__);
	if (sigaction(SIGINT, &sa, NULL) == -1)
	shutdown(1, "sigaction(SIGINT)", __LINE__);
	if (sigaction(SIGQUIT, &sa, NULL) == -1)
	shutdown(1, "sigaction(SIGQUIT)", __LINE__);
	if (sigaction(SIGTERM, &sa, NULL) == -1)
	shutdown(1, "sigaction(SIGTERM)", __LINE__);

	if (!continuous_mode_fake) {
	attr.mq_flags = O_NONBLOCK;
	attr.mq_maxmsg = cur_max_msgs;
	attr.mq_msgsize = MSG_SIZE;
	open_queue(&attr);
	}
	for (i = 0; i < num_cpus_to_pin; i++) {
	pthread_attr_t thread_attr;
	void *thread_func;

	if (continuous_mode_fake)
	thread_func = &fake_cont_thread;
	else if (continuous_mode)
	thread_func = &cont_thread;
	else
	thread_func = &perf_test_thread;

	CPU_ZERO_S(cpu_set_size, cpu_set);
	CPU_SET_S(cpus_to_pin[i], cpu_set_size, cpu_set);
	pthread_attr_init(&thread_attr);
	pthread_attr_setaffinity_np(&thread_attr, cpu_set_size,
	cpu_set);
	if (pthread_create(&cpu_threads[i], &thread_attr, thread_func,
	NULL))
	shutdown(1, "pthread_create()", __LINE__);
	pthread_attr_destroy(&thread_attr);
	}

	if (!continuous_mode) {
	pthread_join(cpu_threads[0], &retval);
	shutdown((long)retval, "perf_test_thread()", __LINE__);
	} else {
	while (1)
	sleep(1);
	}
	shutdown(0, "", 0);
	}