Annotation of fam/fam/Scheduler.c++, Revision 1.1.1.1
1.1 trev 1: // Copyright (C) 1999 Silicon Graphics, Inc. All Rights Reserved.
2: //
3: // This program is free software; you can redistribute it and/or modify it
4: // under the terms of version 2 of the GNU General Public License as
5: // published by the Free Software Foundation.
6: //
7: // This program is distributed in the hope that it would be useful, but
8: // WITHOUT ANY WARRANTY; without even the implied warranty of
9: // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. Further, any
10: // license provided herein, whether implied or otherwise, is limited to
11: // this program in accordance with the express provisions of the GNU
12: // General Public License. Patent licenses, if any, provided herein do not
13: // apply to combinations of this program with other product or programs, or
14: // any other product whatsoever. This program is distributed without any
15: // warranty that the program is delivered free of the rightful claim of any
16: // third person by way of infringement or the like. See the GNU General
17: // Public License for more details.
18: //
19: // You should have received a copy of the GNU General Public License along
20: // with this program; if not, write the Free Software Foundation, Inc., 59
21: // Temple Place - Suite 330, Boston MA 02111-1307, USA.
22:
23: #include "Scheduler.h"
24:
25: #include <assert.h>
26: #include <string.h>
27: #include <errno.h>
28: #include <unistd.h>
29: #include <stdlib.h>
30: #include <sys/param.h>
31:
32: #include "Log.h"
33: #include "timeval.h"
34:
35: // Define a bunch of class-global variables.
36:
37: Scheduler::IOTypeInfo Scheduler::read(&FDInfo::read);
38: Scheduler::IOTypeInfo Scheduler::write(&FDInfo::write);
39: unsigned int Scheduler::nfds;
40: Scheduler::FDInfo *Scheduler::fdinfo;
41: unsigned int Scheduler::nfdinfo_alloc;
42:
43: unsigned int Scheduler::ntasks;
44: Scheduler::TimedProc Scheduler::recurring_proc;
45: void *Scheduler::recurring_closure;
46: timeval Scheduler::next_task_time;
47: timeval Scheduler::recurring_interval;
48: Scheduler::onetime_task *Scheduler::first_task;
49: bool Scheduler::running;
50:
51:
52: //////////////////////////////////////////////////////////////////////////////
53: // One time task code
54:
55: void
56: Scheduler::install_onetime_task(const timeval& when,
57: TimedProc proc, void *closure)
58: {
59: onetime_task **fp = &first_task;
60: while (*fp && (*fp)->when < when)
61: fp = &(*fp)->next;
62: onetime_task *nt = new onetime_task;
63: nt->next = *fp;
64: *fp = nt;
65: nt->when = when;
66: nt->proc = proc;
67: nt->closure = closure;
68: ntasks++;
69: }
70:
71: void
72: Scheduler::remove_onetime_task(TimedProc proc, void *closure)
73: {
74: onetime_task *p, **pp = &first_task;
75: while ((p = *pp) != NULL)
76: {
77: if (p->proc == proc && p->closure == closure)
78: { *pp = p->next;
79: delete p;
80: ntasks--;
81: break;
82: }
83: pp = &p->next;
84: }
85: }
86:
87: //////////////////////////////////////////////////////////////////////////////
88: // Recurring task code
89:
90: void
91: Scheduler::install_recurring_task(const timeval& interval,
92: TimedProc proc, void *closure)
93: {
94: timeval now;
95:
96: assert(!recurring_proc);
97: assert(proc);
98: assert(interval.tv_sec >= 0);
99: assert(interval.tv_usec >= 0 && interval.tv_usec < 1000000);
100: assert(interval.tv_sec || interval.tv_usec);
101:
102: recurring_proc = proc;
103: recurring_closure = closure;
104: recurring_interval = interval;
105: ntasks++;
106: (void) gettimeofday(&now, NULL);
107: next_task_time = now + interval;
108: }
109:
110: void
111: Scheduler::remove_recurring_task(TimedProc proc, void *closure)
112: {
113: assert(proc == recurring_proc);
114: assert(closure == recurring_closure);
115:
116: recurring_proc = NULL;
117: recurring_closure = closure;
118: timerclear(&recurring_interval);
119: ntasks--;
120: }
121:
122: // do_tasks activates all timer based tasks. It also sets
123: // next_task_time to the absolute time when it should next be
124: // invoked.
125:
126: void
127: Scheduler::do_tasks()
128: {
129: if (ntasks)
130: {
131: timeval now;
132: (void) gettimeofday(&now, NULL);
133: if (recurring_proc && now >= next_task_time)
134: {
135: // Time for the next task.
136:
137: (*recurring_proc)(recurring_closure);
138: next_task_time += recurring_interval;
139:
140: // If the clock has jumped ahead or we've gotten too far behind,
141: // postpone the next task.
142:
143: if (next_task_time < now)
144: next_task_time = now + recurring_interval;
145: }
146: else
147: { timeval time_left = next_task_time - now;
148: if (recurring_interval < time_left)
149: {
150: // More time left than we started with -- clock must have
151: // run backward. Reset next_task_time to sane value.
152:
153: next_task_time = now + recurring_interval;
154: }
155: }
156:
157: while (first_task && first_task->when < now)
158: { TimedProc proc = first_task->proc;
159: void *closure = first_task->closure;
160: remove_onetime_task(proc, closure);
161: (*proc)(closure);
162: }
163: }
164: }
165:
166: // calc_timeout calculates the timeout to pass to select().
167: // It returns:
168: // NULL (if no timed tasks exist)
169: // zero time (if it's time for the next task)
170: // nonzero time (if it's not time yet)
171:
172: timeval *
173: Scheduler::calc_timeout()
174: {
175: static timeval sleep_interval;
176:
177: if (ntasks)
178: {
179: timeval wake_time;
180: if (recurring_proc)
181: wake_time = next_task_time;
182: if (!recurring_proc || first_task && first_task->when < wake_time)
183: wake_time = first_task->when;
184: timeval now;
185: (void) gettimeofday(&now, NULL);
186: sleep_interval = wake_time - now;
187: if (sleep_interval.tv_sec < 0)
188: timerclear(&sleep_interval);
189: return &sleep_interval;
190: }
191: else
192: return NULL;
193: }
194:
195: //////////////////////////////////////////////////////////////////////////////
196: // I/O handler code
197:
198: // fd_to_info converts a file descriptor to a pointer into the
199: // fdinfo array. On the way, it verifies that the array has
200: // been allocated far enough out.
201:
202: Scheduler::FDInfo *
203: Scheduler::fd_to_info(int fd)
204: {
205: assert(fd >= 0);
206: if (nfds < fd + 1)
207: {
208: if (nfdinfo_alloc < fd + 1)
209: {
210: unsigned newalloc = nfdinfo_alloc * 3 / 2 + 10;
211: if (newalloc < fd + 1)
212: newalloc = fd + 1;
213: FDInfo *newinfo = new FDInfo[newalloc];
214: for (unsigned i = 0; i < nfds; i++)
215: newinfo[i] = fdinfo[i];
216: delete [] fdinfo;
217: fdinfo = newinfo;
218: nfdinfo_alloc = newalloc;
219: }
220:
221: // Zero all new fdinfo's.
222: memset(&fdinfo[nfds], 0, (fd + 1 - nfds) * sizeof *fdinfo);
223: nfds = fd + 1;
224: }
225: return &fdinfo[fd];
226: }
227:
228: // trim_fdinfo makes the fdinfo array smaller if its last entries
229: // aren't being used. The memory isn't actually freed unless the
230: // array is completely zeroed out.
231:
232: void
233: Scheduler::trim_fdinfo()
234: {
235: for (FDInfo *fp = &fdinfo[nfds - 1]; nfds > 0; --nfds, --fp)
236: if (fp->read.handler || fp->write.handler)
237: break;
238:
239: if (!nfds)
240: { delete [] fdinfo;
241: fdinfo = NULL;
242: nfdinfo_alloc = 0;
243: }
244: }
245:
246: Scheduler::IOHandler
247: Scheduler::install_io_handler(int fd, IOHandler handler, void *closure,
248: IOTypeInfo *iotype)
249: {
250: assert(fd >= 0);
251: assert(handler);
252: FDInfo *fp = fd_to_info(fd);
253: IOHandler old_handler = (fp->*(iotype->iotype)).handler;
254: (fp->*(iotype->iotype)).handler = handler;
255: (fp->*(iotype->iotype)).closure = closure;
256: assert(!old_handler || FD_ISSET(fd, &iotype->fds));
257: if (!FD_ISSET(fd, &iotype->fds))
258: {
259: FD_SET(fd, &iotype->fds);
260: iotype->nbitsset++;
261: }
262: return old_handler;
263: }
264:
265: Scheduler::IOHandler
266: Scheduler::remove_io_handler(int fd, IOTypeInfo *iotype)
267: {
268: assert(fd >= 0 && fd < nfds);
269: FDInfo *fp = fd_to_info(fd);
270: IOHandler old_handler = (fp->*(iotype->iotype)).handler;
271: (fp->*(iotype->iotype)).handler = NULL;
272: (fp->*(iotype->iotype)).closure = NULL;
273: trim_fdinfo();
274: assert(old_handler);
275: if (FD_ISSET(fd, &iotype->fds))
276: {
277: FD_CLR(fd, &iotype->fds);
278: iotype->nbitsset--;
279: }
280: return old_handler;
281: }
282:
283: Scheduler::IOHandler
284: Scheduler::install_read_handler(int fd, IOHandler handler, void *closure)
285: {
286: return install_io_handler(fd, handler, closure, &read);
287: }
288:
289: Scheduler::IOHandler
290: Scheduler::remove_read_handler(int fd)
291: {
292: return remove_io_handler(fd, &read);
293: }
294:
295: Scheduler::IOHandler
296: Scheduler::install_write_handler(int fd, IOHandler handler, void *closure)
297: {
298: return install_io_handler(fd, handler, closure, &write);
299: }
300:
301: Scheduler::IOHandler
302: Scheduler::remove_write_handler(int fd)
303: {
304: return remove_io_handler(fd, &write);
305: }
306:
307: void
308: Scheduler::handle_io(const fd_set *fds, FDInfo::FDIOHandler FDInfo::* iotype)
309: {
310: if (fds)
311: for (int fd = 0; fd < nfds; fd++)
312: if (FD_ISSET(fd, fds))
313: { FDInfo *fp = &fdinfo[fd];
314: assert(iotype == &FDInfo::read || iotype == &FDInfo::write);
315: (fp->*iotype).handler(fd, (fp->*iotype).closure);
316: // Remember, handler may move fdinfo array.
317: }
318: }
319:
320: // Scheduling priorities defined here: writable descriptors have
321: // highest priority, followed by exceptionable descriptors, then
322: // readable descriptors, then timed tasks have the lowest priority.
323:
324: void
325: Scheduler::select()
326: {
327: fd_set readfds, writefds;
328: readfds = Scheduler::read.fds;
329: writefds = Scheduler::write.fds;
330: timeval *timeout = calc_timeout();
331:
332: int status = ::select(nfds, &readfds, &writefds, 0, timeout);
333:
334: if (status == -1 && errno != EINTR)
335: { Log::perror("select"); // Oh, no!
336: ::exit(1);
337: }
338: if (status > 0)
339: {
340: // I/O is ready -- find it and do it.
341:
342: handle_io( &writefds, &FDInfo::write );
343: handle_io( &readfds, &FDInfo::read );
344: }
345:
346: // Check for tasks now.
347:
348: do_tasks();
349: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/back.gif){kind=icon}
Return to Scheduler.c++ CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [Development] / fam / fam