cregit-Linux how code gets into the kernel

Release 4.10 tools/testing/selftests/mqueue/mq_perf_tests.c

/*
 * 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>
#include <error.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); }

Contributors

PersonTokensPropCommitsCommitProp
doug ledforddoug ledford41100.00%1100.00%
Total41100.00%1100.00%


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); }

Contributors

PersonTokensPropCommitsCommitProp
doug ledforddoug ledford155100.00%1100.00%
Total155100.00%1100.00%


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); } }

Contributors

PersonTokensPropCommitsCommitProp
doug ledforddoug ledford62100.00%1100.00%
Total62100.00%1100.00%


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); } }

Contributors

PersonTokensPropCommitsCommitProp
doug ledforddoug ledford63100.00%1100.00%
Total63100.00%1100.00%


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; }

Contributors

PersonTokensPropCommitsCommitProp
doug ledforddoug ledford45100.00%1100.00%
Total45100.00%1100.00%


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__); }

Contributors

PersonTokensPropCommitsCommitProp
doug ledforddoug ledford68100.00%1100.00%
Total68100.00%1100.00%


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; }

Contributors

PersonTokensPropCommitsCommitProp
doug ledforddoug ledford43100.00%1100.00%
Total43100.00%1100.00%


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

Contributors

PersonTokensPropCommitsCommitProp
doug ledforddoug ledford33100.00%1100.00%
Total33100.00%1100.00%


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

Contributors

PersonTokensPropCommitsCommitProp
doug ledforddoug ledford33100.00%1100.00%
Total33100.00%1100.00%

/** * 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); }

Contributors

PersonTokensPropCommitsCommitProp
doug ledforddoug ledford12297.60%150.00%
shuah khanshuah khan32.40%150.00%
Total125100.00%2100.00%


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) ; }

Contributors

PersonTokensPropCommitsCommitProp
doug ledforddoug ledford54100.00%1100.00%
Total54100.00%1100.00%


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); } }

Contributors

PersonTokensPropCommitsCommitProp
doug ledforddoug ledford97100.00%1100.00%
Total97100.00%1100.00%

#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; }

Contributors

PersonTokensPropCommitsCommitProp
doug ledforddoug ledford10100.00%1100.00%
Total10100.00%1100.00%


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

Contributors

PersonTokensPropCommitsCommitProp
doug ledforddoug ledford22100.00%1100.00%
Total22100.00%1100.00%


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

Contributors

PersonTokensPropCommitsCommitProp
doug ledforddoug ledford24100.00%1100.00%
Total24100.00%1100.00%


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

Contributors

PersonTokensPropCommitsCommitProp
doug ledforddoug ledford17100.00%1100.00%
Total17100.00%1100.00%

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; }

Contributors

PersonTokensPropCommitsCommitProp
doug ledforddoug ledford65298.34%150.00%
shuah khanshuah khan111.66%150.00%
Total663100.00%2100.00%


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; }

Contributors

PersonTokensPropCommitsCommitProp
doug ledforddoug ledford93100.00%1100.00%
Total93100.00%1100.00%


int main(int argc, char *argv[]) { struct mq_attr attr; char *option, *next_option; int i, cpu, rc; struct sigaction sa; poptContext popt_context; 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