1/******************************************************************************
2 *
3 *   Copyright © International Business Machines  Corp., 2006, 2008
4 *
5 *   This program is free software;  you can redistribute it and/or modify
6 *   it under the terms of the GNU General Public License as published by
7 *   the Free Software Foundation; either version 2 of the License, or
8 *   (at your option) any later version.
9 *
10 *   This program is distributed in the hope that it will be useful,
11 *   but WITHOUT ANY WARRANTY;  without even the implied warranty of
12 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
13 *   the GNU General Public License for more details.
14 *
15 *   You should have received a copy of the GNU General Public License
16 *   along with this program;  if not, write to the Free Software
17 *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
18 *
19 * NAME
20 *      testpi-7.c
21 *
22 * DESCRIPTION
23 *      measure the latency involved with PI boosting.
24 *
25 *
26 * USAGE:
27 *      Use run_auto.sh script in current directory to build and run test.
28 *
29 * AUTHOR
30 *      Darren Hart <dvhltc@us.ibm.com>
31 *
32 * HISTORY
33 *   2006-May-3: Initial version by Darren Hart <dvhltc@us.ibm.com>
34 *   2006-May-4: Timing fixes reported by Vernon Mauery <vernux@us.ibm.com>
35 *   2006-May-4: Made the med prio threads RT by Darren Hart <dvhltc@us.ibm.com>
36 *   2006-May-5: Modified to use flagging by Vernon Mauery <vernux@us.ibm.com>
37 *
38 *****************************************************************************/
39
40#include <stdio.h>
41#include <stdlib.h>
42#include <math.h>
43#include <librttest.h>
44
45#define HIGH_PRIO 15
46#define MED_PRIO 10
47#define LOW_PRIO  5
48
49#define ITERATIONS 100
50
51#define MED_WORK_MS 20
52#define NS_PER_MS 1000000
53
54static int use_flag_mutex;
55static int max_delay_us;
56static int max_drop2grab_us;
57
58static pthread_mutex_t pi_mutex;
59
60// flagging details
61typedef enum {
62	LOW_START_CYCLE = 1,	// 1
63	MED_START_WORK,		// 2
64	HIGH_GRAB_MUTEX,	// 3
65	LOW_DROP_MUTEX,		// 4
66	END_OF_CYCLE,		// 5
67	END_OF_GAME		// 6
68} phase_t;
69
70static volatile phase_t phase_flag = END_OF_CYCLE;
71
72static pthread_mutex_t flag_mutex;
73
74int med_threads = 0;
75long iterations = ITERATIONS;
76
77void usage(void)
78{
79	rt_help();
80	printf("testpi-7 specific options:\n");
81	printf("  -i#     #: number of iterations\n");
82	printf("  -f      #: Use flag mutex\n");
83	printf("  -x#     #:number of mid priority threads\n");
84}
85
86int parse_args(int c, char *v)
87{
88	int handled = 1;
89	switch (c) {
90	case 'f':
91		use_flag_mutex = 0;
92		break;
93	case 'h':
94		usage();
95		exit(0);
96	case 'i':
97		iterations = atoi(v);
98		break;
99	case 'x':
100		med_threads = atoi(v);
101		break;
102	default:
103		handled = 0;
104		break;
105	}
106	return handled;
107}
108
109phase_t _read_flag(const char *s, int l)
110{
111	phase_t ret;
112	if (use_flag_mutex)
113		pthread_mutex_lock(&flag_mutex);
114	ret = phase_flag;
115	debug(DBG_DEBUG, "%s:%d: read_flag = %s (%d)\n", s, l,
116	      (ret == LOW_START_CYCLE ? "LOW_START_CYCLE" : ret ==
117	       MED_START_WORK ? "MED_START_WORK" : ret ==
118	       HIGH_GRAB_MUTEX ? "HIGH_GRAB_MUTEX" : ret ==
119	       LOW_DROP_MUTEX ? "LOW_DROP_MUTEX" : ret ==
120	       END_OF_CYCLE ? "END_OF_CYCLE" : "ERROR"), ret);
121	//debug(DBG_DEBUG, "%s:%d: read_flag = %d\n", s, l, ret);
122	if (use_flag_mutex)
123		pthread_mutex_unlock(&flag_mutex);
124	return ret;
125}
126
127void _write_flag(const char *s, int l, phase_t new_flag)
128{
129	if (use_flag_mutex)
130		pthread_mutex_lock(&flag_mutex);
131	if (phase_flag != END_OF_GAME) {
132		if (new_flag != phase_flag && new_flag != (phase_flag + 1)
133		    && !(new_flag == LOW_START_CYCLE
134			 && phase_flag == END_OF_CYCLE))
135			printf("YOU'RE HOSED: new_flag=%d, phase_flag=%d\n",
136			       new_flag, phase_flag);
137		phase_flag = new_flag;
138		debug(DBG_DEBUG, "phase_flag: %s set it to %d\n", s,
139		      phase_flag);
140		debug(DBG_DEBUG, "%s:%d: write_flag = %s (%d)\n", s, l,
141		      (new_flag ==
142		       LOW_START_CYCLE ? "LOW_START_CYCLE" : new_flag ==
143		       MED_START_WORK ? "MED_START_WORK" : new_flag ==
144		       HIGH_GRAB_MUTEX ? "HIGH_GRAB_MUTEX" : new_flag ==
145		       LOW_DROP_MUTEX ? "LOW_DROP_MUTEX" : new_flag ==
146		       END_OF_CYCLE ? "END_OF_CYCLE" : "ERROR"), new_flag);
147		//debug(DBG_DEBUG, "%s:%d: write_flag = %d\n", s, l, new_flag);
148	}
149	if (use_flag_mutex)
150		pthread_mutex_unlock(&flag_mutex);
151}
152
153#define read_flag(A) _read_flag(__FUNCTION__,__LINE__)
154#define write_flag(A) _write_flag(__FUNCTION__,__LINE__,A)
155
156#define while_not_flag(A,B) while (read_flag() != (A) && !thread_quit(B))
157
158static nsec_t low_drop_time;
159void *low_prio_rt_thread(void *arg)
160{
161	struct thread *t = (struct thread *)arg;
162	while (!thread_quit(t)) {
163		while_not_flag(LOW_START_CYCLE, t)
164		    rt_nanosleep(1 * NS_PER_MS);
165		debug(DBG_INFO, "low try mutex\n");
166		pthread_mutex_lock(&pi_mutex);
167		debug(DBG_INFO, "low grab mutex\n");
168		write_flag(MED_START_WORK);
169		rt_nanosleep(1 * NS_PER_MS);
170		while_not_flag(LOW_DROP_MUTEX, t) {
171			//printf("!"); fflush(NULL);
172			rt_nanosleep(1);
173		}
174		debug(DBG_INFO, "low drop mutex\n");
175		low_drop_time = rt_gettime();
176		pthread_mutex_unlock(&pi_mutex);
177		while_not_flag(END_OF_CYCLE, t) {
178			//printf("@"); fflush(NULL);
179			rt_nanosleep(1 * NS_PER_MS);
180		}
181	}
182	debug(DBG_INFO, "low prio thread finished (flags=%#x)\n", t->flags);
183	return NULL;
184}
185
186void *med_prio_thread(void *arg)
187{
188	static atomic_t m_flag = { 0 };
189	struct thread *t = (struct thread *)arg;
190#define MP "\t\t\t"
191	while (!thread_quit(t)) {
192		int i_am_the_one;
193		phase_t f;
194		while_not_flag(MED_START_WORK, t) {
195			//printf("."); fflush(NULL);
196			rt_nanosleep(1 * NS_PER_MS);
197		}
198		if ((i_am_the_one = atomic_inc(&m_flag)) == 1) {
199			debug(DBG_INFO, MP "thread %d writing flag\n", t->id);
200			write_flag(HIGH_GRAB_MUTEX);
201		}
202
203		debug(DBG_DEBUG, MP "ready to start work\n");
204		write_flag(HIGH_GRAB_MUTEX);
205		while (((f = read_flag()) == HIGH_GRAB_MUTEX
206			|| f == LOW_DROP_MUTEX) && !thread_quit(t)) {
207			busy_work_ms(MED_WORK_MS);
208			//printf("-"); fflush(NULL);
209		}
210		debug(DBG_DEBUG, MP "done working -- time to sleep\n");
211		if (i_am_the_one == 1) {
212			debug(DBG_INFO, MP "thread %d resetting m_flag\n",
213			      t->id);
214			atomic_set(0, &m_flag);
215		}
216	}
217	debug(DBG_INFO, "med prio thread finished\n");
218	return NULL;
219#undef MP
220}
221
222void *high_prio_rt_thread(void *arg)
223{
224	int delta_us;
225	int i;
226	nsec_t start, now;
227	struct thread *t = (struct thread *)arg;
228	long iterations = (long)t->arg;
229
230#define HP "\t\t\t\t\t"
231	for (i = 0; i < iterations; i++) {
232		debug(DBG_INFO, "Staring iteration %d\n", i);
233		write_flag(LOW_START_CYCLE);
234		while_not_flag(HIGH_GRAB_MUTEX, t) {
235			//printf("a"); fflush(NULL);
236			rt_nanosleep(10 * NS_PER_MS);
237		}
238		debug(DBG_INFO, HP "high try mutex\n");
239		write_flag(LOW_DROP_MUTEX);
240		start = rt_gettime();
241		pthread_mutex_lock(&pi_mutex);
242		now = rt_gettime();
243		debug(DBG_INFO, HP "high grab mutex\n");
244		write_flag(END_OF_CYCLE);
245		debug(DBG_INFO, HP "high drop mutex\n");
246		delta_us = (now - start) / NS_PER_US;
247		if (delta_us > max_delay_us)
248			max_delay_us = delta_us;
249		debug(DBG_WARN, "high prio delay time: %d us\n", delta_us);
250		delta_us = (now - low_drop_time) / NS_PER_US;
251		if (delta_us > max_drop2grab_us)
252			max_drop2grab_us = delta_us;
253		debug(DBG_WARN, "low drop to high grab time: %d us\n",
254		      delta_us);
255		pthread_mutex_unlock(&pi_mutex);
256		rt_nanosleep(10 * NS_PER_MS);
257	}
258	all_threads_quit();
259	write_flag(END_OF_GAME);
260	debug(DBG_INFO, HP "high prio done\n");
261#undef HP
262	return NULL;
263}
264
265int main(int argc, char *argv[])
266{
267	int i, numcpus;
268	setup();
269
270	rt_init("hfi:x:", parse_args, argc, argv);
271
272	if (!med_threads) {
273		printf
274		    ("This test requires that at least NRCPUS medium priority threads run\n");
275		printf
276		    ("If it is run bound to a single CPU, you can specify -x 1\n");
277		printf("No User input , using default value for NRCPUS");
278		numcpus = sysconf(_SC_NPROCESSORS_ONLN);
279		med_threads = numcpus;
280	}
281	printf(" flag mutex: %s\n", use_flag_mutex ? "enabled" : "disabled");
282	printf(" iterations: %ld\n", iterations);
283	printf("med threads: %d\n", med_threads);
284
285	signal(SIGINT, cleanup);
286	signal(SIGQUIT, cleanup);
287	signal(SIGTERM, cleanup);
288
289	max_delay_us = 0;
290	max_drop2grab_us = 0;
291
292	init_pi_mutex(&pi_mutex);
293
294	create_fifo_thread(low_prio_rt_thread, NULL, LOW_PRIO);
295	create_fifo_thread(high_prio_rt_thread, (void *)iterations, HIGH_PRIO);
296	for (i = 0; i < med_threads; i++) {
297		create_fifo_thread(med_prio_thread, NULL, MED_PRIO);
298	}
299
300	while (phase_flag != END_OF_GAME)
301		usleep(100);
302	join_threads();
303	cleanup(0);
304
305	printf("High priority lock aquisition maximum delay: %dus\n",
306	       max_delay_us);
307	printf
308	    ("Low priority lock drop to high priority acqusistion time: %dus\n",
309	     max_drop2grab_us);
310	printf("\n");
311
312	return 0;
313}
314