]>
Commit | Line | Data |
---|---|---|
b0d623f7 A |
1 | /* |
2 | * CDDL HEADER START | |
3 | * | |
4 | * The contents of this file are subject to the terms | |
5 | * of the Common Development and Distribution License | |
6 | * (the "License"). You may not use this file except | |
7 | * in compliance with the License. | |
8 | * | |
9 | * You can obtain a copy of the license at | |
10 | * src/OPENSOLARIS.LICENSE | |
11 | * or http://www.opensolaris.org/os/licensing. | |
12 | * See the License for the specific language governing | |
13 | * permissions and limitations under the License. | |
14 | * | |
15 | * When distributing Covered Code, include this CDDL | |
16 | * HEADER in each file and include the License file at | |
17 | * usr/src/OPENSOLARIS.LICENSE. If applicable, | |
18 | * add the following below this CDDL HEADER, with the | |
19 | * fields enclosed by brackets "[]" replaced with your | |
20 | * own identifying information: Portions Copyright [yyyy] | |
21 | * [name of copyright owner] | |
22 | * | |
23 | * CDDL HEADER END | |
24 | */ | |
25 | ||
26 | /* | |
27 | * Copyright 2005 Sun Microsystems, Inc. All rights reserved. | |
28 | * Use is subject to license terms. | |
29 | */ | |
30 | ||
31 | /* | |
32 | * The "cascade" test case is a multiprocess/multithread batten-passing model | |
33 | * using lock primitives alone for synchronisation. Threads are arranged in a | |
34 | * ring. Each thread has two locks of its own on which it blocks, and is able | |
35 | * to manipulate the two locks belonging to the thread which follows it in the | |
36 | * ring. | |
37 | * | |
38 | * The number of threads (nthreads) is specified by the generic libMicro -P/-T | |
39 | * options. With nthreads == 1 (the default) the uncontended case can be timed. | |
40 | * | |
41 | * The main logic is generic and allows any simple blocking API to be tested. | |
42 | * The API-specific component is clearly indicated. | |
43 | */ | |
44 | ||
45 | #include <unistd.h> | |
46 | #include <stdlib.h> | |
47 | #include <stdio.h> | |
48 | #include <pthread.h> | |
49 | #include <sys/mman.h> | |
50 | ||
51 | #include "libmicro.h" | |
52 | ||
53 | typedef struct { | |
54 | int ts_once; | |
55 | int ts_id; | |
56 | int ts_us0; /* our lock indices */ | |
57 | int ts_us1; | |
58 | int ts_them0; /* their lock indices */ | |
59 | int ts_them1; | |
60 | } tsd_t; | |
61 | ||
62 | static int nthreads; | |
63 | ||
64 | /* | |
65 | * API-specific code BEGINS here | |
66 | */ | |
67 | ||
68 | static int opto = 0; | |
69 | static int opts = 0; | |
70 | static int nlocks; | |
71 | static pthread_mutex_t *mxs; | |
72 | static pthread_cond_t *cvs; | |
73 | static int *conds; | |
74 | ||
75 | int | |
76 | benchmark_init() | |
77 | { | |
78 | lm_tsdsize = sizeof (tsd_t); | |
79 | ||
80 | (void) sprintf(lm_optstr, "os"); | |
81 | ||
82 | lm_defN = "cscd_cond"; | |
83 | ||
84 | (void) sprintf(lm_usage, | |
85 | " [-o] (do signal outside mutex)\n" | |
86 | " [-s] (force PTHREAD_PROCESS_SHARED)\n" | |
87 | "notes: thread cascade using pthread_conds\n"); | |
88 | ||
89 | return (0); | |
90 | } | |
91 | ||
92 | /*ARGSUSED*/ | |
93 | int | |
94 | benchmark_optswitch(int opt, char *optarg) | |
95 | { | |
96 | switch (opt) { | |
97 | case 'o': | |
98 | opto = 1; | |
99 | break; | |
100 | case 's': | |
101 | opts = 1; | |
102 | break; | |
103 | default: | |
104 | return (-1); | |
105 | } | |
106 | return (0); | |
107 | } | |
108 | ||
109 | int | |
110 | benchmark_initrun() | |
111 | { | |
112 | int i; | |
113 | int e = 0; | |
114 | pthread_mutexattr_t ma; | |
115 | pthread_condattr_t ca; | |
116 | ||
117 | nthreads = lm_optP * lm_optT; | |
118 | nlocks = nthreads * 2; | |
119 | /*LINTED*/ | |
120 | mxs = (pthread_mutex_t *)mmap(NULL, | |
121 | nlocks * sizeof (pthread_mutex_t), | |
122 | PROT_READ | PROT_WRITE, | |
123 | MAP_ANON | MAP_SHARED, | |
124 | -1, 0L); | |
125 | if (mxs == MAP_FAILED) { | |
126 | return (1); | |
127 | } | |
128 | ||
129 | /*LINTED*/ | |
130 | cvs = (pthread_cond_t *)mmap(NULL, | |
131 | nlocks * sizeof (pthread_cond_t), | |
132 | PROT_READ | PROT_WRITE, | |
133 | MAP_ANON | MAP_SHARED, | |
134 | -1, 0L); | |
135 | if (cvs == MAP_FAILED) { | |
136 | return (1); | |
137 | } | |
138 | ||
139 | /*LINTED*/ | |
140 | conds = (int *)mmap(NULL, | |
141 | nlocks * sizeof (pthread_cond_t), | |
142 | PROT_READ | PROT_WRITE, | |
143 | MAP_ANON | MAP_SHARED, | |
144 | -1, 0L); | |
145 | if (conds == MAP_FAILED) { | |
146 | return (1); | |
147 | } | |
148 | ||
149 | (void) pthread_mutexattr_init(&ma); | |
150 | (void) pthread_condattr_init(&ca); | |
151 | if (lm_optP > 1 || opts) { | |
152 | (void) pthread_mutexattr_setpshared(&ma, | |
153 | PTHREAD_PROCESS_SHARED); | |
154 | (void) pthread_condattr_setpshared(&ca, | |
155 | PTHREAD_PROCESS_SHARED); | |
156 | } else { | |
157 | (void) pthread_mutexattr_setpshared(&ma, | |
158 | PTHREAD_PROCESS_PRIVATE); | |
159 | (void) pthread_condattr_setpshared(&ca, | |
160 | PTHREAD_PROCESS_PRIVATE); | |
161 | } | |
162 | ||
163 | for (i = 0; i < nlocks; i++) { | |
164 | (void) pthread_mutex_init(&mxs[i], &ma); | |
165 | (void) pthread_cond_init(&cvs[i], &ca); | |
166 | conds[i] = 0; | |
167 | } | |
168 | ||
169 | return (e); | |
170 | } | |
171 | ||
172 | int | |
173 | block(int index) | |
174 | { | |
175 | (void) pthread_mutex_lock(&mxs[index]); | |
176 | while (conds[index] != 0) { | |
177 | (void) pthread_cond_wait(&cvs[index], &mxs[index]); | |
178 | } | |
179 | conds[index] = 1; | |
180 | (void) pthread_mutex_unlock(&mxs[index]); | |
181 | ||
182 | return (0); | |
183 | } | |
184 | ||
185 | int | |
186 | unblock(int index) | |
187 | { | |
188 | (void) pthread_mutex_lock(&mxs[index]); | |
189 | conds[index] = 0; | |
190 | if (opto) { | |
191 | (void) pthread_mutex_unlock(&mxs[index]); | |
192 | (void) pthread_cond_signal(&cvs[index]); | |
193 | } else { | |
194 | (void) pthread_cond_signal(&cvs[index]); | |
195 | (void) pthread_mutex_unlock(&mxs[index]); | |
196 | } | |
197 | return (0); | |
198 | } | |
199 | ||
200 | /* | |
201 | * API-specific code ENDS here | |
202 | */ | |
203 | ||
204 | int | |
205 | benchmark_initbatch(void *tsd) | |
206 | { | |
207 | tsd_t *ts = (tsd_t *)tsd; | |
208 | int e = 0; | |
209 | ||
210 | if (ts->ts_once == 0) { | |
211 | int us, them; | |
212 | ||
213 | #if !defined(__APPLE__) | |
214 | us = (getpindex() * lm_optT) + gettindex(); | |
215 | #else | |
216 | us = gettsdindex(tsd); | |
217 | #endif /* __APPLE__ */ | |
218 | ||
219 | them = (us + 1) % (lm_optP * lm_optT); | |
220 | ||
221 | ts->ts_id = us; | |
222 | ||
223 | /* lock index asignment for us and them */ | |
224 | ts->ts_us0 = (us * 2); | |
225 | ts->ts_us1 = (us * 2) + 1; | |
226 | if (us < nthreads - 1) { | |
227 | /* straight-thru connection to them */ | |
228 | ts->ts_them0 = (them * 2); | |
229 | ts->ts_them1 = (them * 2) + 1; | |
230 | } else { | |
231 | /* cross-over connection to them */ | |
232 | ts->ts_them0 = (them * 2) + 1; | |
233 | ts->ts_them1 = (them * 2); | |
234 | } | |
235 | ||
236 | ts->ts_once = 1; | |
237 | } | |
238 | ||
239 | /* block their first move */ | |
240 | e += block(ts->ts_them0); | |
241 | ||
242 | return (e); | |
243 | } | |
244 | ||
245 | int | |
246 | benchmark(void *tsd, result_t *res) | |
247 | { | |
248 | tsd_t *ts = (tsd_t *)tsd; | |
249 | int i; | |
250 | int e = 0; | |
251 | ||
252 | /* wait to be unblocked (id == 0 will not block) */ | |
253 | e += block(ts->ts_us0); | |
254 | ||
255 | for (i = 0; i < lm_optB; i += 2) { | |
256 | /* allow them to block us again */ | |
257 | e += unblock(ts->ts_us0); | |
258 | ||
259 | /* block their next + 1 move */ | |
260 | e += block(ts->ts_them1); | |
261 | ||
262 | /* unblock their next move */ | |
263 | e += unblock(ts->ts_them0); | |
264 | ||
265 | /* wait for them to unblock us */ | |
266 | e += block(ts->ts_us1); | |
267 | ||
268 | /* repeat with locks reversed */ | |
269 | e += unblock(ts->ts_us1); | |
270 | e += block(ts->ts_them0); | |
271 | e += unblock(ts->ts_them1); | |
272 | e += block(ts->ts_us0); | |
273 | } | |
274 | ||
275 | /* finish batch with nothing blocked */ | |
276 | e += unblock(ts->ts_them0); | |
277 | e += unblock(ts->ts_us0); | |
278 | ||
279 | res->re_count = i; | |
280 | res->re_errors = e; | |
281 | ||
282 | return (0); | |
283 | } |