[apple/xnu.git] / tools / tests / libMicro / apple / lmbench_select_file.c

/*
 * Copyright (c) 2006 Apple Inc.  All Rights Reserved.
 * 
 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
 * 
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. The rights granted to you under the License
 * may not be used to create, or enable the creation or redistribution of,
 * unlawful or unlicensed copies of an Apple operating system, or to
 * circumvent, violate, or enable the circumvention or violation of, any
 * terms of an Apple operating system software license agreement.
 * 
 * Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this file.
 * 
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 * 
 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
 */


/*
 *	Order of Execution
 *
 *	benchmark_init
 *
 *	benchmark_optswitch
 *
 *		benchmark_initrun
 *
 *			benchmark_initworker
 *				benchmark_initbatch
 *					benchmark
 *				benchmark_finibatch
 *				benchmark_initbatch
 *					benchmark
 *				benchmark_finibatch, etc.
 *			benchmark_finiworker
 *
 *		benchmark_result
 *
 *		benchmark_finirun
 *
 *	benchmark_fini
 */


#ifdef	__sun
#pragma ident	"@(#)socket.c	1.3	05/08/04 Apple Inc."
#endif


#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <fcntl.h>
#include <string.h>
#include <errno.h>

#include "../libmicro.h"

/*
 * lmbench routines, etc. brought over for this benchmark
 */
int  open_file(void* tsd);
void server(void* tsd);


typedef int (*open_f)(void* tsd);
/*
 * end of lmbench support routines
 */

/*
 *	Your state variables should live in the tsd_t struct below
 */
typedef struct {
	char	fname[L_tmpnam];
	open_f	fid_f;
	pid_t	pid;
	int	sock;
	int	fid;
	int	num;
	int	max;
	fd_set  set;
} tsd_t;

static int 	optt = 1;
static int 	optn = -1;
static int 	optp = 1;
static int	optw = 0;

/*
 * lmbench routines, etc. brought over for this benchmark
 */
 
void
morefds(void)
{
#ifdef  RLIMIT_NOFILE
        struct  rlimit r;

        getrlimit(RLIMIT_NOFILE, &r);
        r.rlim_cur = r.rlim_max;
        setrlimit(RLIMIT_NOFILE, &r);
#endif
}

int
open_file(void* tsd)
{
	tsd_t* ts = (tsd_t*)tsd;
	//(void) fprintf(stderr, "open_file: ts->fname = %s\n",ts->fname);
	return (int) open(ts->fname, O_RDONLY);
}

void
server(void* tsd)
{
	int pid;
	tsd_t* ts = (tsd_t*)tsd;

	pid = getpid();
	ts->pid = 0;
	//(void) fprintf(stderr, "server: state->fid_f = %i\n",ts->fid_f);
	
	if (ts->fid_f == open_file) {
		/* Create a temporary file for clients to open */
		sprintf(ts->fname, "/tmp/lat_selectXXXXXX");
		//(void) fprintf(stderr, "server: ts->fname = %s\n",ts->fname);
		ts->fid = mkstemp(ts->fname);
		//(void) fprintf(stderr, "server: ts->fname = %s: ts->fid = %d\n",ts->fname, ts->fid);

		if (ts->fid <= 0) {
			char buf[L_tmpnam+128];
			sprintf(buf, "lat_select: Could not create temp file %s", ts->fname);
			perror(buf);
			exit(1);
		}
		close(ts->fid);
		return;
	}
//
//	this is all for the tcp version of this test only
//
// 	/* Create a socket for clients to connect to */
// 	state->sock = tcp_server(TCP_SELECT, SOCKOPT_REUSE);
// 	if (state->sock <= 0) {
// 		perror("lat_select: Could not open tcp server socket");
// 		exit(1);
// 	}

	/* Start a server process to accept client connections */
// 	switch(state->pid = fork()) {
// 	case 0:
// 		/* child server process */
// 		while (pid == getppid()) {
// 			int newsock = tcp_accept(state->sock, SOCKOPT_NONE);
// 			read(newsock, &state->fid, 1);
// 			close(newsock);
// 		}
// 		exit(0);
// 	case -1:
// 		/* error */
// 		perror("lat_select::server(): fork() failed");
// 		exit(1);
// 	default:
// 		break;
// 	}
}


/*
 * end of lmbench support routines
 */

/*ARGSUSED*/
int
benchmark_initbatch(void *tsd)
{
	/*
	 * initialize your state variables here second
	 */
	return (0);
}

int
benchmark_finirun()
{
	//(void) fprintf(stderr, "benchmark_finirun\n");
	return (0);
}

int
benchmark_init()
{
	//(void) fprintf(stderr, "benchmark_init\n");
	/* 
	 *	the lm_optstr must be defined here or no options for you
	 *
	 * 	...and the framework will throw an error
	 *
	 */
	(void) sprintf(lm_optstr, "p:w:n:t:");
	/*
	 *	working hypothesis:
	 *	
	 * 	tsd_t is the struct that we can pass around our
	 *	state info in
	 *
	 *	lm_tsdsize will allocate the space we need for this
	 *	structure throughout the rest of the framework
	 */
	lm_tsdsize = sizeof (tsd_t);

	(void) sprintf(lm_usage,
		"       [-p parallelism (default 1)]\n"			
		"       [-w warmup (default 0)]\n"
		"       [-n number of descriptors (default 1)]\n"
	    "       [-t int (default 1)]\n"
	    "notes: measures lmbench_select_file\n");
	lm_defB = 1;
	return (0);
}

int
benchmark_fini()
{
	//(void) fprintf(stderr, "benchmark_fini\n");
	return (0);
}

int
benchmark_finibatch(void *tsd)
{
	return (0);
}

char *
benchmark_result()
{
	static char		result = '\0';
	//(void) fprintf(stderr, "benchmark_result\n");
	return (&result);
}

int
benchmark_finiworker(void *tsd)
{
	tsd_t			*ts = (tsd_t *)tsd;
	int i;
	// pulls in the lmbench cleanup code
	//(void) fprintf(stderr, "benchmark_finiworker\n");
	for (i = 0; i <= ts->max; ++i) {
		if (FD_ISSET(i, &(ts->set)))
			close(i);
	}
	FD_ZERO(&(ts->set));
	unlink(ts->fname);
	return (0);
}

int
benchmark_optswitch(int opt, char *optarg)
{
	//(void) fprintf(stderr, "benchmark_optswitch\n");
	
	switch (opt) {
	case 't':
		optt = sizetoint(optarg);
		break;
	case 'n':
		optn = sizetoint(optarg);
		break;
	case 'p':
		optp = sizetoint(optarg);
		break;
	case 'w':
		optw = sizetoint(optarg);
		break;
	default:
		return (-1);
	}
	return (0);
}

int
benchmark_initworker(void *tsd)
{	
	// pulls in code from lmbench main and initialize
	int		n = 0;
	/*
	 *	initialize your state variables here first
	 */
	tsd_t			*ts = (tsd_t *)tsd;
	int	N, fid, fd;
	
	/*
	 * default number of file descriptors
	 */
	//(void) fprintf(stderr, "benchmark_initworker\n");
	ts->num = 200;
	if (optn > 0) {
		ts->num = optn;
	}
	N = ts->num;
	//(void) fprintf(stderr, "benchmark_initworker ts->num is %i\n",ts->num);
	
	/*
	 *	grab more file descriptors
	 */
	 
	morefds();
	
	ts->fid_f = open_file;
	server(ts);
	//(void) fprintf(stderr, "benchmark_initworker: returned from server call\n");
	/* 
	 * Initialize function from lmbench
	 * for this test
	 */
	fid = (*ts->fid_f)(ts);
	//(void) fprintf(stderr, "initworker: fid is %i\n",fid);
	if (fid <= 0) {
		perror("Could not open device");
		exit(1);
	}
	ts->max = 0;
	FD_ZERO(&(ts->set));
	//(void) fprintf(stderr, "initworker FD_ZERO: ts->set result is %i\n",ts->set);
	//(void) fprintf(stderr, "initworker: N is %i\n",N);
	for (n = 0; n < N; n++) {
		//(void) fprintf(stderr, "benchmark_initworker: in the loop - N is %i: n is %i\n",N, n);
		fd = dup(fid);
		//(void) fprintf(stderr, "benchmark_initworker: dup result is %i\n",fd);
		//(void) fprintf(stderr, "benchmark_initworker: errno result is %d - \"%s\"\n",errno, strerror(errno));

		if (fd == -1) break;
		if (fd > ts->max)
			ts->max = fd;
		FD_SET(fd, &(ts->set));
		//(void) fprintf(stderr, "initworker FD_SET: ts->set result is %i\n",ts->set);

	}
	//(void) fprintf(stderr, "benchmark_initworker: after second macro/loop\n");

	ts->max++;
	close(fid);
	//(void) fprintf(stderr, "benchmark_initworker: N is %i: n is %i\n",N, n);
	if (n != N)
		exit(1);
	/* end of initialize function */
	//(void) fprintf(stderr, "benchmark_initworker: about to exit\n");
	return (0);
}

int
benchmark_initrun()
{
	//(void) fprintf(stderr, "benchmark_initrun\n");
	return (0);
}

int
benchmark(void *tsd, result_t *res)
{
	/* 
	 *	initialize your state variables here last
	 * 
	 * 	and realize that you are paying for your initialization here
	 *	and it is really a bad idea
	 */
	tsd_t			*ts = (tsd_t *)tsd;
	fd_set		nosave;
	static struct timeval tv;

	//(void) fprintf(stderr, "benchmark\n");

	int			i;
	//int 		sel_res;
	tv.tv_sec = 0;
	tv.tv_usec = 0;

	
	for (i = 0; i < lm_optB; i++) {
		 nosave = ts->set;
		 //(void) fprintf(stderr, "benchmark: nosave is %i\n", nosave);

		 select(ts->num, 0, &nosave, 0, &tv);
		 //(void) fprintf(stderr, "benchmark: select result is %i\n",sel_res);
		 //(void) fprintf(stderr, "benchmark: errno result is %d - \"%s\"\n",errno, strerror(errno));

		 
	}
	res->re_count = i;
	return (0);
}
Commit	Line	Data
b0d623f7 A	1	/*
	2	* Copyright (c) 2006 Apple Inc. All Rights Reserved.
	3	*
	4	* @APPLE_OSREFERENCE_LICENSE_HEADER_START@
	5	*
	6	* This file contains Original Code and/or Modifications of Original Code
	7	* as defined in and that are subject to the Apple Public Source License
	8	* Version 2.0 (the 'License'). You may not use this file except in
	9	* compliance with the License. The rights granted to you under the License
	10	* may not be used to create, or enable the creation or redistribution of,
	11	* unlawful or unlicensed copies of an Apple operating system, or to
	12	* circumvent, violate, or enable the circumvention or violation of, any
	13	* terms of an Apple operating system software license agreement.
	14	*
	15	* Please obtain a copy of the License at
	16	* http://www.opensource.apple.com/apsl/ and read it before using this file.
	17	*
	18	* The Original Code and all software distributed under the License are
	19	* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
	20	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
	21	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
	22	* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
	23	* Please see the License for the specific language governing rights and
	24	* limitations under the License.
	25	*
	26	* @APPLE_OSREFERENCE_LICENSE_HEADER_END@
	27	*/
	28
	29
	30	/*
	31	* Order of Execution
	32	*
	33	* benchmark_init
	34	*
	35	* benchmark_optswitch
	36	*
	37	* benchmark_initrun
	38	*
	39	* benchmark_initworker
	40	* benchmark_initbatch
	41	* benchmark
	42	* benchmark_finibatch
	43	* benchmark_initbatch
	44	* benchmark
	45	* benchmark_finibatch, etc.
	46	* benchmark_finiworker
	47	*
	48	* benchmark_result
	49	*
	50	* benchmark_finirun
	51	*
	52	* benchmark_fini
	53	*/
	54
	55
	56
	57	#ifdef __sun
	58	#pragma ident "@(#)socket.c 1.3 05/08/04 Apple Inc."
	59	#endif
	60
	61
	62
	63	#include <unistd.h>
	64	#include <stdlib.h>
65	#include <stdio.h>
66	#include <fcntl.h>
67	#include <string.h>
68	#include <errno.h>
69
70	#include "../libmicro.h"
71
72	/*
73	* lmbench routines, etc. brought over for this benchmark
74	*/
75	int open_file(void* tsd);
76	void server(void* tsd);
77
78
79	typedef int (open_f)(void tsd);
80	/*
81	* end of lmbench support routines
82	*/
83
84	/*
85	* Your state variables should live in the tsd_t struct below
86	*/
87	typedef struct {
88	char fname[L_tmpnam];
89	open_f fid_f;
90	pid_t pid;
91	int sock;
92	int fid;
93	int num;
94	int max;
95	fd_set set;
96	} tsd_t;
97
98	static int optt = 1;
99	static int optn = -1;
100	static int optp = 1;
101	static int optw = 0;
102
103	/*
104	* lmbench routines, etc. brought over for this benchmark
105	*/
106
107	void
108	morefds(void)
109	{
110	#ifdef RLIMIT_NOFILE
111	struct rlimit r;
112
113	getrlimit(RLIMIT_NOFILE, &r);
114	r.rlim_cur = r.rlim_max;
115	setrlimit(RLIMIT_NOFILE, &r);
116	#endif
117	}
118
119	int
120	open_file(void* tsd)
121	{
122	tsd_t* ts = (tsd_t*)tsd;
123	//(void) fprintf(stderr, "open_file: ts->fname = %s\n",ts->fname);
124	return (int) open(ts->fname, O_RDONLY);
125	}
126
127	void
128	server(void* tsd)
129	{
130	int pid;
131	tsd_t* ts = (tsd_t*)tsd;
132
133	pid = getpid();
134	ts->pid = 0;
135	//(void) fprintf(stderr, "server: state->fid_f = %i\n",ts->fid_f);
136
137	if (ts->fid_f == open_file) {
138	/* Create a temporary file for clients to open */
139	sprintf(ts->fname, "/tmp/lat_selectXXXXXX");
140	//(void) fprintf(stderr, "server: ts->fname = %s\n",ts->fname);
141	ts->fid = mkstemp(ts->fname);
142	//(void) fprintf(stderr, "server: ts->fname = %s: ts->fid = %d\n",ts->fname, ts->fid);
143
144	if (ts->fid <= 0) {
145	char buf[L_tmpnam+128];
146	sprintf(buf, "lat_select: Could not create temp file %s", ts->fname);
147	perror(buf);
148	exit(1);
149	}
150	close(ts->fid);
151	return;
152	}
153	//
154	// this is all for the tcp version of this test only
155	//
156	// /* Create a socket for clients to connect to */
157	// state->sock = tcp_server(TCP_SELECT, SOCKOPT_REUSE);
158	// if (state->sock <= 0) {
159	// perror("lat_select: Could not open tcp server socket");
160	// exit(1);
161	// }
162
163	/* Start a server process to accept client connections */
164	// switch(state->pid = fork()) {
165	// case 0:
166	// /* child server process */
167	// while (pid == getppid()) {
168	// int newsock = tcp_accept(state->sock, SOCKOPT_NONE);
169	// read(newsock, &state->fid, 1);
170	// close(newsock);
171	// }
172	// exit(0);
173	// case -1:
174	// /* error */
175	// perror("lat_select::server(): fork() failed");
176	// exit(1);
177	// default:
178	// break;
179	// }
180	}
181
182
183	/*
184	* end of lmbench support routines
185	*/
186
187	/ARGSUSED/
188	int
189	benchmark_initbatch(void *tsd)
190	{
191	/*
192	* initialize your state variables here second
193	*/
194	return (0);
195	}
196
197	int
198	benchmark_finirun()
199	{
200	//(void) fprintf(stderr, "benchmark_finirun\n");
201	return (0);
202	}
203
204	int
205	benchmark_init()
206	{
207	//(void) fprintf(stderr, "benchmark_init\n");
208	/*
209	* the lm_optstr must be defined here or no options for you
210	*
211	* ...and the framework will throw an error
212	*
213	*/
214	(void) sprintf(lm_optstr, "p:w:n:t:");
215	/*
216	* working hypothesis:
217	*
218	* tsd_t is the struct that we can pass around our
219	* state info in
220	*
221	* lm_tsdsize will allocate the space we need for this
222	* structure throughout the rest of the framework
223	*/
224	lm_tsdsize = sizeof (tsd_t);
225
226	(void) sprintf(lm_usage,
227	" [-p parallelism (default 1)]\n"
228	" [-w warmup (default 0)]\n"
229	" [-n number of descriptors (default 1)]\n"
230	" [-t int (default 1)]\n"
231	"notes: measures lmbench_select_file\n");
232	lm_defB = 1;
233	return (0);
234	}
235
236	int
237	benchmark_fini()
238	{
239	//(void) fprintf(stderr, "benchmark_fini\n");
240	return (0);
241	}
242
243	int
244	benchmark_finibatch(void *tsd)
245	{
246	return (0);
247	}
248
249	char *
250	benchmark_result()
251	{
252	static char result = '\0';
253	//(void) fprintf(stderr, "benchmark_result\n");
254	return (&result);
255	}
256
257	int
258	benchmark_finiworker(void *tsd)
259	{
260	tsd_t ts = (tsd_t )tsd;
261	int i;
262	// pulls in the lmbench cleanup code
263	//(void) fprintf(stderr, "benchmark_finiworker\n");
264	for (i = 0; i <= ts->max; ++i) {
265	if (FD_ISSET(i, &(ts->set)))
266	close(i);
267	}
268	FD_ZERO(&(ts->set));
269	unlink(ts->fname);
270	return (0);
271	}
272
273	int
274	benchmark_optswitch(int opt, char *optarg)
275	{
276	//(void) fprintf(stderr, "benchmark_optswitch\n");
277
278	switch (opt) {
279	case 't':
280	optt = sizetoint(optarg);
281	break;
282	case 'n':
283	optn = sizetoint(optarg);
284	break;
285	case 'p':
286	optp = sizetoint(optarg);
287	break;
288	case 'w':
289	optw = sizetoint(optarg);
290	break;
291	default:
292	return (-1);
293	}
294	return (0);
295	}
296
297	int
298	benchmark_initworker(void *tsd)
299	{
300	// pulls in code from lmbench main and initialize
301	int n = 0;
302	/*
303	* initialize your state variables here first
304	*/
305	tsd_t ts = (tsd_t )tsd;
306	int N, fid, fd;
307
308	/*
309	* default number of file descriptors
310	*/
311	//(void) fprintf(stderr, "benchmark_initworker\n");
312	ts->num = 200;
313	if (optn > 0) {
314	ts->num = optn;
315	}
316	N = ts->num;
317	//(void) fprintf(stderr, "benchmark_initworker ts->num is %i\n",ts->num);
318
319	/*
320	* grab more file descriptors
321	*/
322
323	morefds();
324
325	ts->fid_f = open_file;
326	server(ts);
327	//(void) fprintf(stderr, "benchmark_initworker: returned from server call\n");
328	/*
329	* Initialize function from lmbench
330	* for this test
331	*/
332	fid = (*ts->fid_f)(ts);
333	//(void) fprintf(stderr, "initworker: fid is %i\n",fid);
334	if (fid <= 0) {
335	perror("Could not open device");
336	exit(1);
337	}
338	ts->max = 0;
339	FD_ZERO(&(ts->set));
340	//(void) fprintf(stderr, "initworker FD_ZERO: ts->set result is %i\n",ts->set);
341	//(void) fprintf(stderr, "initworker: N is %i\n",N);
342	for (n = 0; n < N; n++) {
343	//(void) fprintf(stderr, "benchmark_initworker: in the loop - N is %i: n is %i\n",N, n);
344	fd = dup(fid);
345	//(void) fprintf(stderr, "benchmark_initworker: dup result is %i\n",fd);
346	//(void) fprintf(stderr, "benchmark_initworker: errno result is %d - \"%s\"\n",errno, strerror(errno));
347
348	if (fd == -1) break;
349	if (fd > ts->max)
350	ts->max = fd;
351	FD_SET(fd, &(ts->set));
352	//(void) fprintf(stderr, "initworker FD_SET: ts->set result is %i\n",ts->set);
353
354	}
355	//(void) fprintf(stderr, "benchmark_initworker: after second macro/loop\n");
356
357	ts->max++;
358	close(fid);
359	//(void) fprintf(stderr, "benchmark_initworker: N is %i: n is %i\n",N, n);
360	if (n != N)
361	exit(1);
362	/* end of initialize function */
363	//(void) fprintf(stderr, "benchmark_initworker: about to exit\n");
364	return (0);
365	}
366
367	int
368	benchmark_initrun()
369	{
370	//(void) fprintf(stderr, "benchmark_initrun\n");
371	return (0);
372	}
373
374	int
375	benchmark(void tsd, result_t res)
376	{
377	/*
378	* initialize your state variables here last
379	*
380	* and realize that you are paying for your initialization here
381	* and it is really a bad idea
382	*/
383	tsd_t ts = (tsd_t )tsd;
384	fd_set nosave;
385	static struct timeval tv;
386
387	//(void) fprintf(stderr, "benchmark\n");
388
389	int i;
390	//int sel_res;
391	tv.tv_sec = 0;
392	tv.tv_usec = 0;
393
394
395	for (i = 0; i < lm_optB; i++) {
396	nosave = ts->set;
397	//(void) fprintf(stderr, "benchmark: nosave is %i\n", nosave);
398
399	select(ts->num, 0, &nosave, 0, &tv);
400	//(void) fprintf(stderr, "benchmark: select result is %i\n",sel_res);
401	//(void) fprintf(stderr, "benchmark: errno result is %d - \"%s\"\n",errno, strerror(errno));
402
403
404	}
405	res->re_count = i;
406	return (0);
407	}
408