Return to sched.c CVS log

Up to [Research Unix] / researchv9 / jtools / src / demo / pacman

Annotation of researchv9/jtools/src/demo/pacman/sched.c, revision 1.1

1.1     ! root        1: /*----------------------------------------------------------------------*/
        !             2: /*                                                                     */
        !             3: /*     PACMAN for BBN BitGraphs                                        */
        !             4: /*                                                                     */
        !             5: /*               File: sched.c68                                       */
        !             6: /*           Contents: passive real-time-clock-based scheduler         */
        !             7: /*             Author: Bob Brown (rlb)                                 */
        !             8: /*                     Purdue CS                                       */
        !             9: /*               Date: May, 1982                                       */
        !            10: /*        Description: An event list manager for the scheduling        */
        !            11: /*                     of C procedures after given time delays         */
        !            12: /*                                                                     */
        !            13: /*----------------------------------------------------------------------*/
        !            14: 
        !            15: #include "style.h"
        !            16: #include "pacman.h"
        !            17: #define Event PEvent
        !            18: 
        !            19: /*
        !            20: ** Beacuse the scheduler calls routines that re-enqueue themselves,
        !            21: ** The following constant is needed to prevent elpoll() from starving
        !            22: ** the keyboard polling routine when the monsters are running flat-out.
        !            23: */
        !            24: 
        !            25: #define MAXLOOPS 5
        !            26: 
        !            27: /*
        !            28: ** elinit() - initialize the event list to empty.
        !            29: ** eladd() - add an event to the event list.
        !            30: ** elpoll() - called at in polling loop to run scheduled events.
        !            31: */
        !            32: 
        !            33: /*
        !            34: **  MAXEVENTS ...
        !            35: **
        !            36: **     1 for pacman
        !            37: **     4 for monsters
        !            38: **     4 for power pill effects
        !            39: **     1 for bonus fruits
        !            40: **     3 for tone generators
        !            41: */
        !            42: 
        !            43: #define MAXEVENTS      13
        !            44: #define ENULL          ((event *) 0)
        !            45: 
        !            46: typedef struct ev {
        !            47:        struct ev *next;
        !            48:        int time;
        !            49:        int (*routine)();       /* procedure to call */
        !            50:        char *arg0;             /* optional first argument */
        !            51:        int arg1;               /* optional second argument */
        !            52: } event;
        !            53: 
        !            54: event *Eventfree;
        !            55: event *Eventhead;
        !            56: event Event[MAXEVENTS];
        !            57: 
        !            58: extern int clock;
        !            59: 
        !            60: elinit()
        !            61: {
        !            62:        register event *ep;
        !            63:        Eventfree = ENULL;
        !            64:        for ( ep=Event ; ep<&Event[MAXEVENTS] ; ep++ ) {
        !            65:                ep->next = Eventfree;
        !            66:                Eventfree = ep;
        !            67:        }
        !            68:        Eventhead = ENULL;
        !            69:        clock = 0;
        !            70: }
        !            71: /*
        !            72: ** eladd - add an event to the event list
        !            73: */
        !            74: /* VARARGS 2 */
        !            75: eladd(delta,routine,arg0,arg1)
        !            76: int delta;
        !            77: int (*routine)();
        !            78: char *arg0;
        !            79: int arg1;
        !            80: {
        !            81:        int time;
        !            82:        register event *ep, *pp, *cp;
        !            83: 
        !            84: #ifdef BLIT
        !            85:        delta = (delta+8)/16;
        !            86: #endif
        !            87: #ifdef V1_25
        !            88:        delta = (delta+5)/10;
        !            89: #endif
        !            90: 
        !            91:        if ( Eventfree == ENULL ) {
        !            92: #ifndef BLIT
        !            93:                error("Event list overflow");
        !            94: #endif
        !            95:                return;
        !            96:        }
        !            97:        cp = Eventfree;
        !            98:        Eventfree = Eventfree->next;
        !            99: 
        !           100:        time = delta+clock;
        !           101:        cp->time = time;
        !           102:        cp->routine = routine;
        !           103:        cp->arg0 = arg0;
        !           104:        cp->arg1 = arg1;
        !           105: 
        !           106:        ep = Eventhead;
        !           107:        pp = ENULL;
        !           108:        while ( ep!=ENULL && time>ep->time ) {
        !           109:                pp = ep;
        !           110:                ep = ep->next;
        !           111:        }
        !           112:        cp->next = ep;
        !           113:        if ( pp == ENULL )
        !           114:                Eventhead = cp;
        !           115:        else
        !           116:                pp->next = cp;
        !           117: }
        !           118: /*
        !           119: ** elpoll - check if anything to schedule
        !           120: */
        !           121: elpoll()
        !           122: {
        !           123:        register int maxloops;
        !           124:        register event *ep;
        !           125:        maxloops = MAXLOOPS;
        !           126:        while ( (ep=Eventhead)!=ENULL && ep->time < clock && --maxloops > 0) {
        !           127:                Eventhead = ep->next;
        !           128:                (*ep->routine)(ep->arg0,ep->arg1);
        !           129:                ep->next = Eventfree;
        !           130:                Eventfree = ep;
        !           131:        }
        !           132: }
        !           133: /*
        !           134: ** eladjust - adjust the scheduler based on processor delay
        !           135: */
        !           136: eladjust(ms)
        !           137: register int ms;
        !           138: {
        !           139: #ifdef BLIT
        !           140:        ms = (ms+8)/16;
        !           141: #endif
        !           142: #ifdef V1_25
        !           143:        ms = (ms+5)/10;
        !           144: #endif
        !           145:        clock -= ms;
        !           146: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.