Return to Scheduler.h CVS log

Up to [Development] / fam / fam

Annotation of fam/fam/Scheduler.h, 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: #ifndef Scheduler_included
                     24: #define Scheduler_included
                     25:
                     26: #include <sys/time.h>
                     27: #include <string.h>
                     28:
                     29: #include "Boolean.h"
                     30:
                     31: //  Scheduler is a class encapsulating a simple event and timer based
                     32: //  task scheduler.  Tasks are simply subroutines that are activated
                     33: //  by calling them.
                     34: //
                     35: //  A recurring task will be activated at fixed intervals of real
                     36: //  time.  It is unpredictable when the Scheduler will first activate
                     37: //  a recurring task.
                     38: //
                     39: //  A onetime task will be activated at a particular time.
                     40: //
                     41: //  Events are those defined by select(2) -- file descriptors that are
                     42: //  ready to be read, written or checked for exceptional conditions.
                     43: //  A handler may be installed to be called for any event on any
                     44: //  descriptor.  Only one handler may be installed for each event.
                     45: //  The installation and removal routines return the previously
                     46: //  installed handler.
                     47: //
                     48: //  Scheduler has fixed priorities -- write events precede exception
                     49: //  events precede read events precede timed tasks.
                     50: //
                     51: //  USE: There are no instances of Scheduler; all its interface
                     52: //  routines are static, and are called, e.g., "Scheduler::loop();"
                     53: //
                     54: //  RESTRICTIONS: Because we currently need only a single recurring
                     55: //  task, multiple recurring tasks are not implemented.
                     56:
                     57: class Scheduler {
                     58:
                     59: public:
                     60:
                     61:     typedef void (*IOHandler)(int fd, void *closure);
                     62:     typedef void (*TimedProc)(void *closure);
                     63:
                     64:     //  One-time tasks.
                     65:
                     66:     static void install_onetime_task(const timeval& when,
                     67: 				     TimedProc, void *closure);
                     68:     static void remove_onetime_task(TimedProc, void *closure);
                     69:
                     70:     //  Recurring tasks.
                     71:
                     72:     static void install_recurring_task(const timeval& interval,
                     73: 				       TimedProc, void *closure);
                     74:     static void remove_recurring_task(TimedProc, void *closure);
                     75:
                     76:     //  I/O handlers.
                     77:
                     78:     static IOHandler install_read_handler(int fd, IOHandler, void *closure);
                     79:     static IOHandler remove_read_handler(int fd);
                     80:
                     81:     static IOHandler install_write_handler(int fd, IOHandler, void *closure);
                     82:     static IOHandler remove_write_handler(int fd);
                     83:
                     84:     //  Mainline code.
                     85:
                     86:     static void select();
                     87:     static void exit()			{ running = false; }
                     88:     static void loop()			{ running = true;
                     89: 					  while (running) select(); }
                     90:
                     91: private:
                     92:
                     93:     //  Per-filedescriptor info is the set of three handlers and their
                     94:     //  closures.
                     95:
                     96:     struct FDInfo {
                     97: 	struct FDIOHandler {
                     98: 	    IOHandler handler;
                     99: 	    void *closure;
                    100: 	} read, write;
                    101:     };
                    102:
                    103:     //  Per-I/O type info is the file descriptor set passed to select(),
                    104:     //  the number of bits set there, and the offset into the FDInfo
                    105:     //  for the corresponding I/O type.
                    106:
                    107:     struct IOTypeInfo {
                    108: 	FDInfo::FDIOHandler FDInfo::*iotype;
                    109: 	unsigned int nbitsset;		// number of bits set in fds
                    110: 	fd_set fds;
                    111: 	IOTypeInfo(FDInfo::FDIOHandler FDInfo::* a_iotype) :
                    112:             iotype(a_iotype), nbitsset(0) { FD_ZERO(&fds); }
                    113:     };
                    114:
                    115:     struct onetime_task {
                    116: 	onetime_task *next;
                    117: 	timeval when;
                    118: 	Scheduler::TimedProc proc;
                    119: 	void *closure;
                    120:     };
                    121:
                    122:     // I/O event related variables
                    123:
                    124:     static IOTypeInfo read, write;
                    125:     static FDInfo *fdinfo;
                    126:     static unsigned int nfds;
                    127:     static unsigned int nfdinfo_alloc;
                    128:
                    129:     // Timed task related variables
                    130:
                    131:     static unsigned int ntasks;
                    132:     static timeval next_task_time;
                    133:     static TimedProc recurring_proc;
                    134:     static void *recurring_closure;
                    135:     static timeval recurring_interval;
                    136:     static onetime_task *first_task;
                    137:     static bool running;
                    138:
                    139:     // I/O event related functions
                    140:
                    141:     static FDInfo *fd_to_info(int fd);
                    142:     static void trim_fdinfo();
                    143:     static IOHandler install_io_handler(int fd,
                    144: 					IOHandler handler, void *closure,
                    145: 					IOTypeInfo *iotype);
                    146:     static IOHandler remove_io_handler(int fd, IOTypeInfo *iotype);
                    147:     static void handle_io(const fd_set *fds, FDInfo::FDIOHandler FDInfo::* iotype);
                    148:
                    149:     // Timed task related functions
                    150:
                    151:     static void do_tasks();
                    152:     static timeval *calc_timeout();
                    153:
                    154:     Scheduler();			// Never instantiate a Scheduler.
                    155:
                    156: };
                    157:
                    158: #endif /* !Scheduler_included */