1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 *
25 * Portions Copyright 2008 Denis Cheng
26 */
27
28 /*
29 * The event generator in this module is the producer half of a
30 * metering system which blocks flows using consumer routines in the
31 * flowop_library.c module. Four routines in that module can limit rates
32 * by event rate (flowoplib_eventlimit), by I/O operations rate
33 * (flowoplib_iopslimit()), by operations rate (flowoplib_opslimit),
34 * or by I/O bandwidth limit (flowoplib_bwlimit). By setting appropriate
35 * event generation rates, required calls per second, I/O ops per second,
36 * file system ops per second, or I/O bandwidth per second limits can
37 * be set. Note, the generated events are shared with all consumer
38 * flowops, of which their will be one for each process / thread
39 * instance which has a consumer flowop defined in it.
40 */
41
42 #include <sys/time.h>
43
44 #include "filebench.h"
45 #include "vars.h"
46 #include "eventgen.h"
47 #include "flowop.h"
48 #include "ipc.h"
49
50 /*
51 * Prints "how to use" information for the eventgen module
52 */
53 void
54 eventgen_usage(void)
55 {
56 (void) fprintf(stderr, "eventgen rate=<rate>\n");
57 (void) fprintf(stderr, "\n");
58 }
59
60 /*
61 * The producer side of the event system.
62 * Once eventgen_hz has been set by eventgen_setrate(),
63 * the routine sends eventgen_hz events per second until
64 * the program terminates. Events are posted by incrementing
65 * filebench_shm->shm_eventgen_q by the number of generated
66 * events then signalling the condition variable
67 * filebench_shm->shm_eventgen_cv to indicate to event consumers
68 * that more events are available.
69 *
70 * Eventgen_thread attempts to sleep for 10 event periods,
71 * then, once awakened, determines how many periods actually
72 * passed since sleeping, and issues a set of events equal
73 * to the number of periods that it slept, thus keeping the
74 * average rate at the requested rate.
75 */
76 static void
77 eventgen_thread(void)
78 {
79 hrtime_t last;
80
81 last = gethrtime();
82 filebench_shm->shm_eventgen_enabled = FALSE;
83
84 /* CONSTCOND */
85 while (1) {
86 struct timespec sleeptime;
87 hrtime_t delta;
88 int count, rate;
89
90 if (filebench_shm->shm_eventgen_hz == NULL) {
91 (void) sleep(1);
92 continue;
93 } else {
94 rate = avd_get_int(filebench_shm->shm_eventgen_hz);
95 if (rate > 0) {
96 filebench_shm->shm_eventgen_enabled = TRUE;
97 } else {
98 continue;
99 }
100 }
101
102 /* Sleep for 10xperiod */
103 sleeptime.tv_sec = 0;
104 sleeptime.tv_nsec = FB_SEC2NSEC / rate;
105
106 sleeptime.tv_nsec *= 10;
107 if (sleeptime.tv_nsec < 1000UL)
108 sleeptime.tv_nsec = 1000UL;
109
110 sleeptime.tv_sec = sleeptime.tv_nsec / FB_SEC2NSEC;
111 if (sleeptime.tv_sec > 0)
112 sleeptime.tv_nsec -= (sleeptime.tv_sec * FB_SEC2NSEC);
113
114 (void) nanosleep(&sleeptime, NULL);
115 delta = gethrtime() - last;
116 last = gethrtime();
117 count = (rate * delta) / FB_SEC2NSEC;
118
119 filebench_log(LOG_DEBUG_SCRIPT,
120 "delta %llums count %d",
121 (u_longlong_t)(delta / 1000000), count);
122
123 /* Send 'count' events */
124 (void) ipc_mutex_lock(&filebench_shm->shm_eventgen_lock);
125 /* Keep the producer with a max of 5 second depth */
126 if (filebench_shm->shm_eventgen_q < (5 * rate))
127 filebench_shm->shm_eventgen_q += count;
128
129 (void) pthread_cond_signal(&filebench_shm->shm_eventgen_cv);
130
131 (void) ipc_mutex_unlock(&filebench_shm->shm_eventgen_lock);
132 }
133 }
134
135 /*
136 * Creates a thread to run the event generator eventgen_thread
137 * routine. Shuts down filebench if the eventgen thread cannot
138 * be created.
139 */
140 void
141 eventgen_init(void)
142 {
143 /*
144 * Linux does not like it if the first
145 * argument to pthread_create is null. It actually
146 * segv's. -neel
147 */
148 pthread_t tid;
149
150 if (pthread_create(&tid, NULL,
151 (void *(*)(void*))eventgen_thread, 0) != 0) {
152 filebench_log(LOG_ERROR, "create timer thread failed: %s",
153 strerror(errno));
154 filebench_shutdown(1);
155 }
156 }
157
158 /*
159 * Puts the current event rate in the integer portion of the
160 * supplied var_t. Returns a pointer to the var_t.
161 */
162 var_t *
163 eventgen_ratevar(var_t *var)
164 {
165 VAR_SET_INT(var, avd_get_int(filebench_shm->shm_eventgen_hz));
166 return (var);
167 }
168
169 /*
170 * Sets the event generator rate to that supplied by
171 * var_t *rate.
172 */
173 void
174 eventgen_setrate(avd_t rate)
175 {
176 filebench_shm->shm_eventgen_hz = rate;
177 if (rate == NULL) {
178 filebench_log(LOG_ERROR,
179 "eventgen_setrate() called without a rate");
180 return;
181 }
182
183 if (AVD_IS_VAR(rate)) {
184 filebench_log(LOG_VERBOSE,
185 "Eventgen rate taken from variable");
186 } else {
187 filebench_log(LOG_VERBOSE, "Eventgen: %llu per second",
188 (u_longlong_t)avd_get_int(rate));
189 }
190 }
191
192 /*
193 * Clears the event queue so we have a clean start
194 */
195 void
196 eventgen_reset(void)
197 {
198 filebench_shm->shm_eventgen_q = 0;
199 }