[apple/xnu.git] / tools / tests / MMTest / MMtest.c

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <mach/mach.h>
#include <mach/mach_error.h>
#include <mach/notify.h>
#include <servers/bootstrap.h>
#include <sys/types.h>
#include <sys/time.h>
#include <sys/signal.h>

#define MAX(A, B) ((A) < (B) ? (B) : (A))

static __inline__ unsigned long long ReadTSR() {
	union {
		unsigned long long time64;
		unsigned long word[2];
	} now;
#if defined(__i386__)
	/* Read from Pentium and Pentium Pro 64-bit timestamp counter.
	 * The counter is set to 0 at processor reset and increments on
	 * every clock cycle. */
	__asm__ volatile("rdtsc" : : : "eax", "edx");
	__asm__ volatile("movl %%eax,%0" : "=m" (now.word[0]) : : "eax");
	__asm__ volatile("movl %%edx,%0" : "=m" (now.word[1]) : : "edx");
#elif defined(__ppc__)
	/* Read from PowerPC 64-bit time base register. The increment
	 * rate of the time base is implementation-dependent, but is
	 * 1/4th the bus clock cycle on 603/604 processors. */
	unsigned long t3;
	do {
		__asm__ volatile("mftbu %0" : "=r" (now.word[0]));
		__asm__ volatile("mftb %0" : "=r" (now.word[1]));
		__asm__ volatile("mftbu %0" : "=r" (t3));
	} while (now.word[0] != t3);
#else
#warning Do not know how to read a time stamp register on this architecture
	now.time64 = 0ULL;
#endif
	return now.time64;
}

typedef struct  {
	unsigned int        msgt_name : 8,
			    msgt_size : 8,
			    msgt_number : 12,
			    msgt_inline : 1,
			    msgt_longform : 1,
			    msgt_deallocate : 1,
			    msgt_unused : 1;
} mach_msg_type_t;

typedef struct  {
	mach_msg_type_t     msgtl_header;
	unsigned short      msgtl_name;
	unsigned short      msgtl_size;
	natural_t           msgtl_number;
} mach_msg_type_long_t;
#define MACH_MSG_TYPE_INTEGER_32 0


typedef struct {
	mach_msg_header_t	header;
	mach_msg_trailer_t	trailer;		// subtract this when sending
} ipc_trivial_message;

typedef struct {
	mach_msg_header_t	header;
	mach_msg_type_t		type;
	u_int32_t		numbers[0];
	mach_msg_trailer_t	trailer;		// subtract this when sending
} ipc_inline_message;

typedef struct {
	mach_msg_header_t		header;
	mach_msg_body_t			body;
	mach_msg_ool_descriptor_t	descriptor;
	mach_msg_trailer_t		trailer;	// subtract this when sending
} ipc_complex_message;

enum {
	msg_type_trivial = 0,
	msg_type_inline = 1,
	msg_type_complex = 2
};

struct port_args {
	int req_size;
	mach_msg_header_t *req_msg;
	int reply_size;
	mach_msg_header_t *reply_msg;
	mach_port_t port;
};

/* Global options */
static int verbose;
int oneway;
int msg_type;
int num_ints;
int num_msgs;
int num_clients;
int client_delay;
char *server_port_name;

void signal_handler(int sig) {
}

void usage(const char *progname) {
	fprintf(stderr, "usage: %s [options]\n", progname);
	fprintf(stderr, "where options are:\n");
	fprintf(stderr, "    -verbose\t\tbe verbose\n");
	fprintf(stderr, "    -oneway\t\tdo not request return reply\n");
	fprintf(stderr, "    -count num\t\tnumber of messages to send\n");
	fprintf(stderr, "    -type trivial|inline|complex\ttype of messages to send\n");
	fprintf(stderr, "    -numints num\tnumber of 32-bit ints to send in messages\n");
	fprintf(stderr, "    -clients num\tnumber of client threads to run\n");
	fprintf(stderr, "    -delay num\t\tmicroseconds to sleep clients between messages\n");
	fprintf(stderr, "    -name portname\tname of port on which to communicate\n");
	fprintf(stderr, "default values are:\n");
	fprintf(stderr, "    . not verbose\n");
	fprintf(stderr, "    . not oneway\n");
	fprintf(stderr, "    . client sends 10000 messages\n");
	fprintf(stderr, "    . inline message type\n");
	fprintf(stderr, "    . 64 32-bit integers in inline/complex messages\n");
	fprintf(stderr, "    . avail_cpus - 1 clients\n");
	fprintf(stderr, "    . no delay\n");
	fprintf(stderr, "    . port name 'TEST'\n");
	exit(1);
}

void parse_args(int argc, char *argv[]) {
	host_basic_info_data_t		info;
	mach_msg_type_number_t		count;
	kern_return_t			result;

	/* Initialize defaults */
	verbose = 0;
	oneway = 0;
	msg_type = msg_type_trivial;
	num_ints = 64;
	num_msgs = 10000;
	client_delay = 0;
	server_port_name = "TEST";

	count = HOST_BASIC_INFO_COUNT;
	result = host_info(mach_host_self(), HOST_BASIC_INFO, 
			(host_info_t)&info, &count);
	if (result == KERN_SUCCESS)
		num_clients = MAX(1, info.avail_cpus - 1);
	else
		num_clients = 1;

	const char *progname = argv[0];
	argc--; argv++;
	while (0 < argc) {
		if (0 == strcmp("-verbose", argv[0])) {
			verbose = 1;
			argc--; argv++;
		} else if (0 == strcmp("-oneway", argv[0])) {
			oneway = 1;
			argc--; argv++;
		} else if (0 == strcmp("-type", argv[0])) {
			if (argc < 2) 
				usage(progname);
			if (0 == strcmp("trivial", argv[1])) {
				msg_type = msg_type_trivial;
			} else if (0 == strcmp("inline", argv[1])) {
				msg_type = msg_type_inline;
			} else if (0 == strcmp("complex", argv[1])) {
				msg_type = msg_type_complex;
			} else 
				usage(progname);
			argc -= 2; argv += 2;
		} else if (0 == strcmp("-name", argv[0])) {
			if (argc < 2) 
				usage(progname);
			server_port_name = argv[1];
			argc -= 2; argv += 2;
		} else if (0 == strcmp("-numints", argv[0])) {
			if (argc < 2) 
				usage(progname);
			num_ints = strtoul(argv[1], NULL, 0);
			argc -= 2; argv += 2;
		} else if (0 == strcmp("-count", argv[0])) {
			if (argc < 2) 
				usage(progname);
			num_msgs = strtoul(argv[1], NULL, 0);
			argc -= 2; argv += 2;
		}  else if (0 == strcmp("-clients", argv[0])) {
			if (argc < 2) 
				usage(progname);
			num_clients = strtoul(argv[1], NULL, 0);
			argc -= 2; argv += 2;
		} else if (0 == strcmp("-delay", argv[0])) {
			if (argc < 2) 
				usage(progname);
			client_delay = strtoul(argv[1], NULL, 0);
			argc -= 2; argv += 2;
		} else 
			usage(progname);
	}
}

void setup_server_ports(struct port_args *ports)
{
	kern_return_t ret = 0;
	mach_port_t bsport;

	ports->req_size = MAX(sizeof(ipc_inline_message) +  
			sizeof(u_int32_t) * num_ints, 
			sizeof(ipc_complex_message));
	ports->reply_size = sizeof(ipc_trivial_message) - 
		sizeof(mach_msg_trailer_t);
	ports->req_msg = malloc(ports->req_size);
	ports->reply_msg = malloc(ports->reply_size);

	ret = mach_port_allocate(mach_task_self(), 
			MACH_PORT_RIGHT_RECEIVE,  
			&(ports->port));
	if (KERN_SUCCESS != ret) {
		mach_error("mach_port_allocate(): ", ret);
		exit(1);
	}

	ret = mach_port_insert_right(mach_task_self(), 
			ports->port, 
			ports->port, 
			MACH_MSG_TYPE_MAKE_SEND);
	if (KERN_SUCCESS != ret) {
		mach_error("mach_port_insert_right(): ", ret);
		exit(1);
	}

	ret = task_get_bootstrap_port(mach_task_self(), &bsport);
	if (KERN_SUCCESS != ret) {
		mach_error("task_get_bootstrap_port(): ", ret);
		exit(1);
	}

	ret = bootstrap_register(bsport, server_port_name, ports->port);
	if (KERN_SUCCESS != ret) {
		mach_error("bootstrap_register(): ", ret);
		exit(1);
	}
	if (verbose) {
		printf("server waiting for IPC messages from client on port '%s'.\n",
				server_port_name);
	}
}

void setup_client_ports(struct port_args *ports)
{
	kern_return_t ret = 0;
	switch(msg_type) {
		case msg_type_trivial:
			ports->req_size = sizeof(ipc_trivial_message);
			break;
		case msg_type_inline:
			ports->req_size = sizeof(ipc_inline_message) +  
				sizeof(u_int32_t) * num_ints;
			break;
		case msg_type_complex:
			ports->req_size = sizeof(ipc_complex_message);
			break;
	}
	ports->req_size -= sizeof(mach_msg_trailer_t);
	ports->reply_size = sizeof(ipc_trivial_message);
	ports->req_msg = malloc(ports->req_size);
	ports->reply_msg = malloc(ports->reply_size);

	ret = mach_port_allocate(mach_task_self(), 
			MACH_PORT_RIGHT_RECEIVE,  
			&(ports->port));
	if (KERN_SUCCESS != ret) {
		mach_error("mach_port_allocate(): ", ret);
		exit(1);
	}
	if (verbose) {
		printf("Client sending %d %s IPC messages to port '%s' in %s mode.\n",
				num_msgs, (msg_type == msg_type_inline) ? 
				"inline" :  ((msg_type == msg_type_complex) ? 
					"complex" : "trivial"),  
				server_port_name, (oneway ? "oneway" : "rpc"));
	}

}

void server(struct port_args *args) 
{
	int idx;
	kern_return_t ret;
	int totalmsg = num_msgs * num_clients;

	unsigned long long starttsc, endtsc, deltatsc;
	struct timeval starttv, endtv, deltatv;

	/* Call gettimeofday() once and throw away result; some implementations
	 * (like Mach's) cache some time zone info on first call.  Then, call
	 * ReadTSR in case that helps warm things up, again discarding the 
	 * results.
	 */
	gettimeofday(&starttv, NULL);
	ReadTSR();

	gettimeofday(&starttv, NULL);
	starttsc = ReadTSR();

	for (idx = 0; idx < totalmsg; idx++) {
		if (verbose) 
			printf("server awaiting message %d\n", idx);
		args->req_msg->msgh_bits = 0;
		args->req_msg->msgh_size = args->req_size;
		args->req_msg->msgh_local_port = args->port;
		ret = mach_msg(args->req_msg,  
				MACH_RCV_MSG|MACH_RCV_INTERRUPT|MACH_RCV_LARGE, 
				0, 
				args->req_size,  
				args->port, 
				MACH_MSG_TIMEOUT_NONE, 
				MACH_PORT_NULL);
		if (MACH_MSG_SUCCESS != ret) {
			mach_error("mach_msg (receive): ", ret);
			exit(1);
		}
		if (verbose)
			printf("server received message %d\n", idx);
		if (args->req_msg->msgh_bits & MACH_MSGH_BITS_COMPLEX) {
			ret = vm_deallocate(mach_task_self(),  
					(vm_address_t)((ipc_complex_message *)args->req_msg)->descriptor.address,  
					((ipc_complex_message *)args->req_msg)->descriptor.size);
		}

		if (1 == args->req_msg->msgh_id) {
			if (verbose) 
				printf("server sending reply %d\n", idx);
			args->reply_msg->msgh_bits = MACH_MSGH_BITS(MACH_MSG_TYPE_COPY_SEND,  
					MACH_MSG_TYPE_MAKE_SEND);
			args->reply_msg->msgh_size = args->reply_size;
			args->reply_msg->msgh_remote_port = args->req_msg->msgh_remote_port;
			args->reply_msg->msgh_local_port = args->req_msg->msgh_local_port;
			args->reply_msg->msgh_id = 2;
			ret = mach_msg(args->reply_msg, 
					MACH_SEND_MSG, 
					args->reply_size, 
					0, 
					MACH_PORT_NULL, 
					MACH_MSG_TIMEOUT_NONE,  
					MACH_PORT_NULL);
			if (MACH_MSG_SUCCESS != ret) {
				mach_error("mach_msg (send): ", ret);
				exit(1);
			}
		}
	}

	endtsc = ReadTSR();
	gettimeofday(&endtv, NULL);

	/* report results */
	deltatsc = endtsc - starttsc;
	deltatv.tv_sec = endtv.tv_sec - starttv.tv_sec;
	deltatv.tv_usec = endtv.tv_usec - starttv.tv_usec;
	if (endtv.tv_usec < starttv.tv_usec) {
		deltatv.tv_sec--;
		deltatv.tv_usec += 1000000;
	}

	double dsecs = (double) deltatv.tv_sec + 
		1.0E-6 * (double) deltatv.tv_usec;

	printf("\n%u messages during %qd time stamp ticks\n", 
			totalmsg, deltatsc);
	printf("%g time stamp ticks per message\n", 
			(double) deltatsc / (double) totalmsg);
	printf("\n%u messages during %u.%06u seconds\n",  
			totalmsg, deltatv.tv_sec, deltatv.tv_usec);
	printf("%g messages per second\n", (double)totalmsg /  dsecs);
	printf("%g microseconds per message\n\n", 
			dsecs * 1.0E6 / (double) totalmsg); 
}

void *client(void *threadarg) 
{
	struct port_args args;
	int idx;
	mach_msg_header_t *req, *reply; 
	mach_port_t bsport, servport;
	kern_return_t ret;
	void *ints = malloc(sizeof(u_int32_t) * num_ints);

	/* find server port */
	ret = task_get_bootstrap_port(mach_task_self(), &bsport);
	if (KERN_SUCCESS != ret) {
		mach_error("task_get_bootstrap_port(): ", ret);
		exit(1);
	}
	ret = bootstrap_look_up(bsport, server_port_name, &servport); 
	if (KERN_SUCCESS != ret) {
		mach_error("bootstrap_look_up(): ", ret);
		exit(1);
	}

	setup_client_ports(&args);
	
	/* start message loop */
	for (idx = 0; idx < num_msgs; idx++) {
		req = args.req_msg;
		reply = args.reply_msg;

		req->msgh_bits = MACH_MSGH_BITS(MACH_MSG_TYPE_COPY_SEND, 
				MACH_MSG_TYPE_MAKE_SEND);
		req->msgh_size = args.req_size;
		req->msgh_remote_port = servport;
		req->msgh_local_port = args.port;
		req->msgh_id = oneway ? 0 : 1;
		switch (msg_type) {
			case msg_type_trivial:
				break;
			case msg_type_inline:
				((ipc_inline_message *)req)->type.msgt_name = MACH_MSG_TYPE_INTEGER_32;
				((ipc_inline_message *)req)->type.msgt_size = 32;
				((ipc_inline_message *)req)->type.msgt_number = num_ints;
				((ipc_inline_message *)req)->type.msgt_inline = TRUE;
				((ipc_inline_message *)req)->type.msgt_longform = FALSE;
				((ipc_inline_message *)req)->type.msgt_deallocate = FALSE;
				((ipc_inline_message *)req)->type.msgt_unused = 0;
				break;
			case msg_type_complex:
				(req)->msgh_bits |=  MACH_MSGH_BITS_COMPLEX;
				((ipc_complex_message *)req)->body.msgh_descriptor_count = 1;
				((ipc_complex_message *)req)->descriptor.address = ints;
				((ipc_complex_message *)req)->descriptor.size = 
					num_ints * sizeof(u_int32_t);
				((ipc_complex_message *)req)->descriptor.deallocate = FALSE;
				((ipc_complex_message *)req)->descriptor.copy = MACH_MSG_VIRTUAL_COPY;
				((ipc_complex_message *)req)->descriptor.type = MACH_MSG_OOL_DESCRIPTOR;
				break;
		}
		if (verbose) 
			printf("client sending message %d\n", idx);
		ret = mach_msg(req,  
				MACH_SEND_MSG, 
				args.req_size, 
				0, 
				MACH_PORT_NULL,  
				MACH_MSG_TIMEOUT_NONE, 
				MACH_PORT_NULL);
		if (MACH_MSG_SUCCESS != ret) {
			mach_error("mach_msg (send): ", ret);
			fprintf(stderr, "bailing after %u iterations\n", idx);
			exit(1);
			break;
		}
		if (!oneway) {
			if (verbose) 
				printf("client awaiting reply %d\n", idx);
			reply->msgh_bits = 0;
			reply->msgh_size = args.reply_size;
			reply->msgh_local_port = args.port;
			ret = mach_msg(args.reply_msg,  
					MACH_RCV_MSG|MACH_RCV_INTERRUPT, 
					0, 
					args.reply_size, 
					args.port,  
					MACH_MSG_TIMEOUT_NONE, 
					MACH_PORT_NULL);
			if (MACH_MSG_SUCCESS != ret) {
				mach_error("mach_msg (receive): ", ret);
				fprintf(stderr, "bailing after %u iterations\n",
						idx);
				exit(1);
			}
			if (verbose) 
				printf("client received reply %d\n", idx);
		}

		if (client_delay) {
			usleep(client_delay);
		}
	}

	free(ints);
	return;
}


int main(int argc, char *argv[]) 
{
	struct port_args portargs;
	int i;

	signal(SIGINT, signal_handler);
	parse_args(argc, argv);

	setup_server_ports(&portargs);

	if (fork() != 0) {
		server(&portargs);
		exit(0);
	}

	if (num_clients > 1) {
		for (i = 1; i < num_clients; i++) {
			if (fork() == 0) {
				client(NULL);
				exit(0);
			}
		}
	}

	client(NULL);

	return (0);
}
Commit	Line	Data
2d21ac55 A	1	#include <pthread.h>
	2	#include <stdio.h>
	3	#include <stdlib.h>
	4	#include <string.h>
	5
	6	#include <mach/mach.h>
	7	#include <mach/mach_error.h>
	8	#include <mach/notify.h>
	9	#include <servers/bootstrap.h>
	10	#include <sys/types.h>
	11	#include <sys/time.h>
	12	#include <sys/signal.h>
	13
	14	#define MAX(A, B) ((A) < (B) ? (B) : (A))
	15
	16	static __inline__ unsigned long long ReadTSR() {
	17	union {
	18	unsigned long long time64;
	19	unsigned long word[2];
	20	} now;
	21	#if defined(__i386__)
	22	/* Read from Pentium and Pentium Pro 64-bit timestamp counter.
	23	* The counter is set to 0 at processor reset and increments on
	24	* every clock cycle. */
	25	__asm__ volatile("rdtsc" : : : "eax", "edx");
	26	__asm__ volatile("movl %%eax,%0" : "=m" (now.word[0]) : : "eax");
	27	__asm__ volatile("movl %%edx,%0" : "=m" (now.word[1]) : : "edx");
	28	#elif defined(__ppc__)
	29	/* Read from PowerPC 64-bit time base register. The increment
	30	* rate of the time base is implementation-dependent, but is
	31	* 1/4th the bus clock cycle on 603/604 processors. */
	32	unsigned long t3;
	33	do {
	34	__asm__ volatile("mftbu %0" : "=r" (now.word[0]));
	35	__asm__ volatile("mftb %0" : "=r" (now.word[1]));
	36	__asm__ volatile("mftbu %0" : "=r" (t3));
	37	} while (now.word[0] != t3);
	38	#else
	39	#warning Do not know how to read a time stamp register on this architecture
	40	now.time64 = 0ULL;
	41	#endif
	42	return now.time64;
	43	}
	44
	45	typedef struct {
	46	unsigned int msgt_name : 8,
	47	msgt_size : 8,
	48	msgt_number : 12,
	49	msgt_inline : 1,
	50	msgt_longform : 1,
	51	msgt_deallocate : 1,
	52	msgt_unused : 1;
	53	} mach_msg_type_t;
	54
	55	typedef struct {
	56	mach_msg_type_t msgtl_header;
	57	unsigned short msgtl_name;
	58	unsigned short msgtl_size;
	59	natural_t msgtl_number;
	60	} mach_msg_type_long_t;
	61	#define MACH_MSG_TYPE_INTEGER_32 0
	62
	63
	64	typedef struct {
65	mach_msg_header_t header;
66	mach_msg_trailer_t trailer; // subtract this when sending
67	} ipc_trivial_message;
68
69	typedef struct {
70	mach_msg_header_t header;
71	mach_msg_type_t type;
72	u_int32_t numbers[0];
73	mach_msg_trailer_t trailer; // subtract this when sending
74	} ipc_inline_message;
75
76	typedef struct {
77	mach_msg_header_t header;
78	mach_msg_body_t body;
79	mach_msg_ool_descriptor_t descriptor;
80	mach_msg_trailer_t trailer; // subtract this when sending
81	} ipc_complex_message;
82
83	enum {
84	msg_type_trivial = 0,
85	msg_type_inline = 1,
86	msg_type_complex = 2
87	};
88
89	struct port_args {
90	int req_size;
91	mach_msg_header_t *req_msg;
92	int reply_size;
93	mach_msg_header_t *reply_msg;
94	mach_port_t port;
95	};
96
97	/* Global options */
98	static int verbose;
99	int oneway;
100	int msg_type;
101	int num_ints;
102	int num_msgs;
103	int num_clients;
104	int client_delay;
105	char *server_port_name;
106
107	void signal_handler(int sig) {
108	}
109
110	void usage(const char *progname) {
111	fprintf(stderr, "usage: %s [options]\n", progname);
112	fprintf(stderr, "where options are:\n");
113	fprintf(stderr, " -verbose\t\tbe verbose\n");
114	fprintf(stderr, " -oneway\t\tdo not request return reply\n");
115	fprintf(stderr, " -count num\t\tnumber of messages to send\n");
116	fprintf(stderr, " -type trivial\|inline\|complex\ttype of messages to send\n");
117	fprintf(stderr, " -numints num\tnumber of 32-bit ints to send in messages\n");
118	fprintf(stderr, " -clients num\tnumber of client threads to run\n");
119	fprintf(stderr, " -delay num\t\tmicroseconds to sleep clients between messages\n");
120	fprintf(stderr, " -name portname\tname of port on which to communicate\n");
121	fprintf(stderr, "default values are:\n");
122	fprintf(stderr, " . not verbose\n");
123	fprintf(stderr, " . not oneway\n");
124	fprintf(stderr, " . client sends 10000 messages\n");
125	fprintf(stderr, " . inline message type\n");
126	fprintf(stderr, " . 64 32-bit integers in inline/complex messages\n");
127	fprintf(stderr, " . avail_cpus - 1 clients\n");
128	fprintf(stderr, " . no delay\n");
129	fprintf(stderr, " . port name 'TEST'\n");
130	exit(1);
131	}
132
133	void parse_args(int argc, char *argv[]) {
134	host_basic_info_data_t info;
135	mach_msg_type_number_t count;
136	kern_return_t result;
137
138	/* Initialize defaults */
139	verbose = 0;
140	oneway = 0;
141	msg_type = msg_type_trivial;
142	num_ints = 64;
143	num_msgs = 10000;
144	client_delay = 0;
145	server_port_name = "TEST";
146
147	count = HOST_BASIC_INFO_COUNT;
148	result = host_info(mach_host_self(), HOST_BASIC_INFO,
149	(host_info_t)&info, &count);
150	if (result == KERN_SUCCESS)
151	num_clients = MAX(1, info.avail_cpus - 1);
152	else
153	num_clients = 1;
154
155	const char *progname = argv[0];
156	argc--; argv++;
157	while (0 < argc) {
158	if (0 == strcmp("-verbose", argv[0])) {
159	verbose = 1;
160	argc--; argv++;
161	} else if (0 == strcmp("-oneway", argv[0])) {
162	oneway = 1;
163	argc--; argv++;
164	} else if (0 == strcmp("-type", argv[0])) {
165	if (argc < 2)
166	usage(progname);
167	if (0 == strcmp("trivial", argv[1])) {
168	msg_type = msg_type_trivial;
169	} else if (0 == strcmp("inline", argv[1])) {
170	msg_type = msg_type_inline;
171	} else if (0 == strcmp("complex", argv[1])) {
172	msg_type = msg_type_complex;
173	} else
174	usage(progname);
175	argc -= 2; argv += 2;
176	} else if (0 == strcmp("-name", argv[0])) {
177	if (argc < 2)
178	usage(progname);
179	server_port_name = argv[1];
180	argc -= 2; argv += 2;
181	} else if (0 == strcmp("-numints", argv[0])) {
182	if (argc < 2)
183	usage(progname);
184	num_ints = strtoul(argv[1], NULL, 0);
185	argc -= 2; argv += 2;
186	} else if (0 == strcmp("-count", argv[0])) {
187	if (argc < 2)
188	usage(progname);
189	num_msgs = strtoul(argv[1], NULL, 0);
190	argc -= 2; argv += 2;
191	} else if (0 == strcmp("-clients", argv[0])) {
192	if (argc < 2)
193	usage(progname);
194	num_clients = strtoul(argv[1], NULL, 0);
195	argc -= 2; argv += 2;
196	} else if (0 == strcmp("-delay", argv[0])) {
197	if (argc < 2)
198	usage(progname);
199	client_delay = strtoul(argv[1], NULL, 0);
200	argc -= 2; argv += 2;
201	} else
202	usage(progname);
203	}
204	}
205
206	void setup_server_ports(struct port_args *ports)
207	{
208	kern_return_t ret = 0;
209	mach_port_t bsport;
210
211	ports->req_size = MAX(sizeof(ipc_inline_message) +
212	sizeof(u_int32_t) * num_ints,
213	sizeof(ipc_complex_message));
214	ports->reply_size = sizeof(ipc_trivial_message) -
215	sizeof(mach_msg_trailer_t);
216	ports->req_msg = malloc(ports->req_size);
217	ports->reply_msg = malloc(ports->reply_size);
218
219	ret = mach_port_allocate(mach_task_self(),
220	MACH_PORT_RIGHT_RECEIVE,
221	&(ports->port));
222	if (KERN_SUCCESS != ret) {
223	mach_error("mach_port_allocate(): ", ret);
224	exit(1);
225	}
226
227	ret = mach_port_insert_right(mach_task_self(),
228	ports->port,
229	ports->port,
230	MACH_MSG_TYPE_MAKE_SEND);
231	if (KERN_SUCCESS != ret) {
232	mach_error("mach_port_insert_right(): ", ret);
233	exit(1);
234	}
235
236	ret = task_get_bootstrap_port(mach_task_self(), &bsport);
237	if (KERN_SUCCESS != ret) {
238	mach_error("task_get_bootstrap_port(): ", ret);
239	exit(1);
240	}
241
242	ret = bootstrap_register(bsport, server_port_name, ports->port);
243	if (KERN_SUCCESS != ret) {
244	mach_error("bootstrap_register(): ", ret);
245	exit(1);
246	}
247	if (verbose) {
248	printf("server waiting for IPC messages from client on port '%s'.\n",
249	server_port_name);
250	}
251	}
252
253	void setup_client_ports(struct port_args *ports)
254	{
255	kern_return_t ret = 0;
256	switch(msg_type) {
257	case msg_type_trivial:
258	ports->req_size = sizeof(ipc_trivial_message);
259	break;
260	case msg_type_inline:
261	ports->req_size = sizeof(ipc_inline_message) +
262	sizeof(u_int32_t) * num_ints;
263	break;
264	case msg_type_complex:
265	ports->req_size = sizeof(ipc_complex_message);
266	break;
267	}
268	ports->req_size -= sizeof(mach_msg_trailer_t);
269	ports->reply_size = sizeof(ipc_trivial_message);
270	ports->req_msg = malloc(ports->req_size);
271	ports->reply_msg = malloc(ports->reply_size);
272
273	ret = mach_port_allocate(mach_task_self(),
274	MACH_PORT_RIGHT_RECEIVE,
275	&(ports->port));
276	if (KERN_SUCCESS != ret) {
277	mach_error("mach_port_allocate(): ", ret);
278	exit(1);
279	}
280	if (verbose) {
281	printf("Client sending %d %s IPC messages to port '%s' in %s mode.\n",
282	num_msgs, (msg_type == msg_type_inline) ?
283	"inline" : ((msg_type == msg_type_complex) ?
284	"complex" : "trivial"),
285	server_port_name, (oneway ? "oneway" : "rpc"));
286	}
287
288	}
289
290	void server(struct port_args *args)
291	{
292	int idx;
293	kern_return_t ret;
294	int totalmsg = num_msgs * num_clients;
295
296	unsigned long long starttsc, endtsc, deltatsc;
297	struct timeval starttv, endtv, deltatv;
298
299	/* Call gettimeofday() once and throw away result; some implementations
300	* (like Mach's) cache some time zone info on first call. Then, call
301	* ReadTSR in case that helps warm things up, again discarding the
302	* results.
303	*/
304	gettimeofday(&starttv, NULL);
305	ReadTSR();
306
307	gettimeofday(&starttv, NULL);
308	starttsc = ReadTSR();
309
310	for (idx = 0; idx < totalmsg; idx++) {
311	if (verbose)
312	printf("server awaiting message %d\n", idx);
313	args->req_msg->msgh_bits = 0;
314	args->req_msg->msgh_size = args->req_size;
315	args->req_msg->msgh_local_port = args->port;
316	ret = mach_msg(args->req_msg,
317	MACH_RCV_MSG\|MACH_RCV_INTERRUPT\|MACH_RCV_LARGE,
318	0,
319	args->req_size,
320	args->port,
321	MACH_MSG_TIMEOUT_NONE,
322	MACH_PORT_NULL);
323	if (MACH_MSG_SUCCESS != ret) {
324	mach_error("mach_msg (receive): ", ret);
325	exit(1);
326	}
327	if (verbose)
328	printf("server received message %d\n", idx);
329	if (args->req_msg->msgh_bits & MACH_MSGH_BITS_COMPLEX) {
330	ret = vm_deallocate(mach_task_self(),
331	(vm_address_t)((ipc_complex_message *)args->req_msg)->descriptor.address,
332	((ipc_complex_message *)args->req_msg)->descriptor.size);
333	}
334
335	if (1 == args->req_msg->msgh_id) {
336	if (verbose)
337	printf("server sending reply %d\n", idx);
338	args->reply_msg->msgh_bits = MACH_MSGH_BITS(MACH_MSG_TYPE_COPY_SEND,
339	MACH_MSG_TYPE_MAKE_SEND);
340	args->reply_msg->msgh_size = args->reply_size;
341	args->reply_msg->msgh_remote_port = args->req_msg->msgh_remote_port;
342	args->reply_msg->msgh_local_port = args->req_msg->msgh_local_port;
343	args->reply_msg->msgh_id = 2;
344	ret = mach_msg(args->reply_msg,
345	MACH_SEND_MSG,
346	args->reply_size,
347	0,
348	MACH_PORT_NULL,
349	MACH_MSG_TIMEOUT_NONE,
350	MACH_PORT_NULL);
351	if (MACH_MSG_SUCCESS != ret) {
352	mach_error("mach_msg (send): ", ret);
353	exit(1);
354	}
355	}
356	}
357
358	endtsc = ReadTSR();
359	gettimeofday(&endtv, NULL);
360
361	/* report results */
362	deltatsc = endtsc - starttsc;
363	deltatv.tv_sec = endtv.tv_sec - starttv.tv_sec;
364	deltatv.tv_usec = endtv.tv_usec - starttv.tv_usec;
365	if (endtv.tv_usec < starttv.tv_usec) {
366	deltatv.tv_sec--;
367	deltatv.tv_usec += 1000000;
368	}
369
370	double dsecs = (double) deltatv.tv_sec +
371	1.0E-6 * (double) deltatv.tv_usec;
372
373	printf("\n%u messages during %qd time stamp ticks\n",
374	totalmsg, deltatsc);
375	printf("%g time stamp ticks per message\n",
376	(double) deltatsc / (double) totalmsg);
377	printf("\n%u messages during %u.%06u seconds\n",
378	totalmsg, deltatv.tv_sec, deltatv.tv_usec);
379	printf("%g messages per second\n", (double)totalmsg / dsecs);
380	printf("%g microseconds per message\n\n",
381	dsecs * 1.0E6 / (double) totalmsg);
382	}
383
384	void client(void threadarg)
385	{
386	struct port_args args;
387	int idx;
388	mach_msg_header_t req, reply;
389	mach_port_t bsport, servport;
390	kern_return_t ret;
391	void ints = malloc(sizeof(u_int32_t) num_ints);
392
393	/* find server port */
394	ret = task_get_bootstrap_port(mach_task_self(), &bsport);
395	if (KERN_SUCCESS != ret) {
396	mach_error("task_get_bootstrap_port(): ", ret);
397	exit(1);
398	}
399	ret = bootstrap_look_up(bsport, server_port_name, &servport);
400	if (KERN_SUCCESS != ret) {
401	mach_error("bootstrap_look_up(): ", ret);
402	exit(1);
403	}
404
405	setup_client_ports(&args);
406
407	/* start message loop */
408	for (idx = 0; idx < num_msgs; idx++) {
409	req = args.req_msg;
410	reply = args.reply_msg;
411
412	req->msgh_bits = MACH_MSGH_BITS(MACH_MSG_TYPE_COPY_SEND,
413	MACH_MSG_TYPE_MAKE_SEND);
414	req->msgh_size = args.req_size;
415	req->msgh_remote_port = servport;
416	req->msgh_local_port = args.port;
417	req->msgh_id = oneway ? 0 : 1;
418	switch (msg_type) {
419	case msg_type_trivial:
420	break;
421	case msg_type_inline:
422	((ipc_inline_message *)req)->type.msgt_name = MACH_MSG_TYPE_INTEGER_32;
423	((ipc_inline_message *)req)->type.msgt_size = 32;
424	((ipc_inline_message *)req)->type.msgt_number = num_ints;
425	((ipc_inline_message *)req)->type.msgt_inline = TRUE;
426	((ipc_inline_message *)req)->type.msgt_longform = FALSE;
427	((ipc_inline_message *)req)->type.msgt_deallocate = FALSE;
428	((ipc_inline_message *)req)->type.msgt_unused = 0;
429	break;
430	case msg_type_complex:
431	(req)->msgh_bits \|= MACH_MSGH_BITS_COMPLEX;
432	((ipc_complex_message *)req)->body.msgh_descriptor_count = 1;
433	((ipc_complex_message *)req)->descriptor.address = ints;
434	((ipc_complex_message *)req)->descriptor.size =
435	num_ints * sizeof(u_int32_t);
436	((ipc_complex_message *)req)->descriptor.deallocate = FALSE;
437	((ipc_complex_message *)req)->descriptor.copy = MACH_MSG_VIRTUAL_COPY;
438	((ipc_complex_message *)req)->descriptor.type = MACH_MSG_OOL_DESCRIPTOR;
439	break;
440	}
441	if (verbose)
442	printf("client sending message %d\n", idx);
443	ret = mach_msg(req,
444	MACH_SEND_MSG,
445	args.req_size,
446	0,
447	MACH_PORT_NULL,
448	MACH_MSG_TIMEOUT_NONE,
449	MACH_PORT_NULL);
450	if (MACH_MSG_SUCCESS != ret) {
451	mach_error("mach_msg (send): ", ret);
452	fprintf(stderr, "bailing after %u iterations\n", idx);
453	exit(1);
454	break;
455	}
456	if (!oneway) {
457	if (verbose)
458	printf("client awaiting reply %d\n", idx);
459	reply->msgh_bits = 0;
460	reply->msgh_size = args.reply_size;
461	reply->msgh_local_port = args.port;
462	ret = mach_msg(args.reply_msg,
463	MACH_RCV_MSG\|MACH_RCV_INTERRUPT,
464	0,
465	args.reply_size,
466	args.port,
467	MACH_MSG_TIMEOUT_NONE,
468	MACH_PORT_NULL);
469	if (MACH_MSG_SUCCESS != ret) {
470	mach_error("mach_msg (receive): ", ret);
471	fprintf(stderr, "bailing after %u iterations\n",
472	idx);
473	exit(1);
474	}
475	if (verbose)
476	printf("client received reply %d\n", idx);
477	}
478
479	if (client_delay) {
480	usleep(client_delay);
481	}
482	}
483
484	free(ints);
485	return;
486	}
487
488
489	int main(int argc, char *argv[])
490	{
491	struct port_args portargs;
492	int i;
493
494	signal(SIGINT, signal_handler);
495	parse_args(argc, argv);
496
497	setup_server_ports(&portargs);
498
499	if (fork() != 0) {
500	server(&portargs);
501	exit(0);
502	}
503
504	if (num_clients > 1) {
505	for (i = 1; i < num_clients; i++) {
506	if (fork() == 0) {
507	client(NULL);
508	exit(0);
509	}
510	}
511	}
512
513	client(NULL);
514
515	return (0);
516	}