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
54 static int use_flag_mutex;
55 static int max_delay_us;
56 static int max_drop2grab_us;
57
58 static pthread_mutex_t pi_mutex;
59
60 // flagging details
61 typedef 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
70 static volatile phase_t phase_flag = END_OF_CYCLE;
71
72 static pthread_mutex_t flag_mutex;
73
74 int med_threads = 0;
75 long iterations = ITERATIONS;
76
usage(void)77 void 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
parse_args(int c,char * v)86 int 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
_read_flag(const char * s,int l)109 phase_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
_write_flag(const char * s,int l,phase_t new_flag)127 void _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
158 static nsec_t low_drop_time;
low_prio_rt_thread(void * arg)159 void *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
med_prio_thread(void * arg)186 void *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
high_prio_rt_thread(void * arg)222 void *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
main(int argc,char * argv[])265 int 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