"I am a person who works hard and plays hard."
Yuan Wei
Second Year Graduate Student Department of Computer Science
University of Virginia Charlottesville, VA 22903
Email: yw3f@cs.virginia.edu

Source Code Analysis

Main Page   Compound List   File List   Compound Members   File Members  

eventq.c File Reference

#include <stdio.h>
#include <stdlib.h>
#include "host.h"
#include "misc.h"
#include "machine.h"
#include "eventq.h"

Include dependency graph for eventq.c:

Include dependency graph

Go to the source code of this file.

Defines

Functions

Variables

Define Documentation

#define __QUEUE_EVENT (  WHEN,
ID,
ACTION    ) 
 

Value:

struct eventq_desc *prev, *ev, *new;                                    \
                                        \
  if (!eventq_free)                                                     \
    {                                                                   \
      if (eventq_max_events && eventq_event_count >= eventq_max_events) \
        panic("too many events");                                       \
      eventq_free = calloc(1, sizeof(struct eventq_desc));              \
    }                                                                   \
  new = eventq_free;                                                    \
  eventq_free = eventq_free->next;                                      \
                                                \
  new->when = (WHEN); (ID) = new->id = next_ID++; ACTION;               \
                                                \
  for (prev=NULL,ev=eventq_pending;                                     \
       ev && ev->when < when;                                           \
       prev=ev, ev=ev->next);                                           \
                                                \
  if (prev)                                                             \
    {                                                                   \
                                        \
      new->next = prev->next;                                           \
      prev->next = new;                                                 \
    }                                                                   \
  else                                                                  \
    {                                                                   \
                                                \
      new->next = eventq_pending;                                       \
      eventq_pending = new;                                             \
    }

Definition at line 96 of file eventq.c.

Referenced by eventq_queue_addop(), eventq_queue_callback(), eventq_queue_clearbit(), eventq_queue_setbit(), and eventq_queue_setflag().

#define EXECUTE_ACTION (  ev,
now    ) 
 

Value:

\
  switch (ev->action) {                                                 \
  case EventSetBit:                                                     \
    BITMAP_SET(ev->data.bit.bmap, ev->data.bit.sz, ev->data.bit.bitnum);\
    break;                                                              \
  case EventClearBit:                                                   \
    BITMAP_CLEAR(ev->data.bit.bmap, ev->data.bit.sz, ev->data.bit.bitnum);\
    break;                                                              \
  case EventSetFlag:                                                    \
    *ev->data.flag.pflag = ev->data.flag.value;                         \
    break;                                                              \
  case EventAddOp:                                                      \
    *ev->data.addop.summand += ev->data.addop.addend;                   \
    break;                                                              \
  case EventCallback:                                                   \
    (*ev->data.callback.fn)(now, ev->data.callback.arg);                \
    break;                                                              \
  default:                                                              \
    panic("bogus event action");                                        \
  }

Definition at line 181 of file eventq.c.

Referenced by eventq_execute(), and eventq_service_events().

Function Documentation

void eventq_dump (  FILE *    stream ) 
 

Definition at line 292 of file eventq.c.

References eventq_desc::action, eventq_desc::eventq_data::addop, eventq_desc::eventq_data::bit, eventq_desc::eventq_data::callback, eventq_desc::data, EventAddOp, EventCallback, EventClearBit, EventSetBit, EventSetFlag, eventq_desc::eventq_data::flag, eventq_desc::next, panic(), and eventq_desc::when. 

00293 {
00294   struct eventq_desc *ev;
00295 
00296   if (!stream)
00297     stream = stderr;
00298 
00299   fprintf(stream, "Pending Events: ");
00300   for (ev=eventq_pending; ev; ev=ev->next)
00301     {
00302       fprintf(stream, "@ %.0f:%s:",
00303               (double)ev->when,
00304               ev->action == EventSetBit ? "set bit"
00305               : ev->action == EventClearBit ? "clear bit"
00306               : ev->action == EventSetFlag ? "set flag"
00307               : ev->action == EventAddOp ? "add operation"
00308               : ev->action == EventCallback ? "call back"
00309               : (abort(), ""));
00310       switch (ev->action) {
00311       case EventSetBit:
00312       case EventClearBit:
00313         fprintf(stream, "0x%p, %d, %d",
00314                 ev->data.bit.bmap, ev->data.bit.sz, ev->data.bit.bitnum);
00315         break;
00316       case EventSetFlag:
00317         fprintf(stream, "0x%p, %d", ev->data.flag.pflag, ev->data.flag.value);
00318         break;
00319       case EventAddOp:
00320         fprintf(stream, "0x%p, %d",
00321                 ev->data.addop.summand, ev->data.addop.addend);
00322         break;
00323       case EventCallback:
00324         fprintf(stream, "0x%p, %d",
00325                 ev->data.callback.fn, ev->data.callback.arg);
00326         break;
00327       default:
00328         panic("bogus event action");
00329       }
00330       fprintf(stream, " ");
00331     }
00332 }

int eventq_execute (  EVENTQ_ID_TYPE    id ) 
 

Definition at line 206 of file eventq.c.

References EVENTQ_ID_TYPE, EXECUTE_ACTION, FALSE, eventq_desc::id, eventq_desc::next, and TRUE. 

00207 {
00208   struct eventq_desc *prev, *ev;
00209 
00210   for (prev=NULL,ev=eventq_pending; ev; prev=ev,ev=ev->next)
00211     {
00212       if (ev->id == id)
00213         {
00214           if (prev)
00215             {
00216               /* middle of end of list */
00217               prev->next = ev->next;
00218             }
00219           else /* !prev */
00220             {
00221               /* beginning of list */
00222               eventq_pending = ev->next;
00223             }
00224 
00225           /* handle action, now is munged */
00226           EXECUTE_ACTION(ev, 0);
00227 
00228           /* put event on free list */
00229           ev->next = eventq_free;
00230           eventq_free = ev;
00231 
00232           /* return success */
00233           return TRUE;
00234         }
00235     }
00236   /* not found */
00237   return FALSE;
00238 }

void eventq_init (  int    max_events ) 
 

Definition at line 88 of file eventq.c. 

00089 {
00090   eventq_max_events = max_events;
00091   eventq_event_count = 0;
00092   eventq_pending = NULL;
00093   eventq_free = NULL;
00094 }

EVENTQ_ID_TYPE eventq_queue_addop (  SS_TIME_TYPE    when,
int *    summand,
int    addend
) 
 

Definition at line 160 of file eventq.c.

References __QUEUE_EVENT, EventAddOp, and EVENTQ_ID_TYPE. 

00161 {
00162   EVENTQ_ID_TYPE id;
00163   __QUEUE_EVENT(when, id,                                               \
00164                 new->action = EventAddOp;                               \
00165                 new->data.addop.summand = summand;                      \
00166                 new->data.addop.addend = addend);
00167   return id;
00168 }

EVENTQ_ID_TYPE eventq_queue_callback (  SS_TIME_TYPE    when,
void(*    fn)(SS_TIME_TYPE time, int arg),
int    arg
) 
 

Definition at line 171 of file eventq.c.

References __QUEUE_EVENT, EventCallback, and EVENTQ_ID_TYPE. 

00173 {
00174   EVENTQ_ID_TYPE id;
00175   __QUEUE_EVENT(when, id,                                               \
00176                 new->action = EventCallback; new->data.callback.fn = fn;\
00177                 new->data.callback.arg = arg);
00178   return id;
00179 }

EVENTQ_ID_TYPE eventq_queue_clearbit (  SS_TIME_TYPE    when,
BITMAP_ENT_TYPE *    bmap,
int    sz,
int    bitnum
) 
 

Definition at line 139 of file eventq.c.

References __QUEUE_EVENT, BITMAP_ENT_TYPE, EventClearBit, and EVENTQ_ID_TYPE. 

00141 {
00142   EVENTQ_ID_TYPE id;
00143   __QUEUE_EVENT(when, id,                                               \
00144                 new->action = EventClearBit; new->data.bit.bmap = bmap; \
00145                 new->data.bit.sz = sz; new->data.bit.bitnum = bitnum);
00146   return id;
00147 }

EVENTQ_ID_TYPE eventq_queue_setbit (  SS_TIME_TYPE    when,
BITMAP_ENT_TYPE *    bmap,
int    sz,
int    bitnum
) 
 

Definition at line 128 of file eventq.c.

References __QUEUE_EVENT, BITMAP_ENT_TYPE, EVENTQ_ID_TYPE, and EventSetBit. 

00130 {
00131   EVENTQ_ID_TYPE id;
00132   __QUEUE_EVENT(when, id,                                               \
00133                 new->action = EventSetBit; new->data.bit.bmap = bmap;   \
00134                 new->data.bit.sz = sz; new->data.bit.bitnum = bitnum);
00135   return id;
00136 }

EVENTQ_ID_TYPE eventq_queue_setflag (  SS_TIME_TYPE    when,
int *    pflag,
int    value
) 
 

Definition at line 150 of file eventq.c.

References __QUEUE_EVENT, EVENTQ_ID_TYPE, and EventSetFlag. 

00151 {
00152   EVENTQ_ID_TYPE id;
00153   __QUEUE_EVENT(when, id,                                               \
00154                 new->action = EventSetFlag;                             \
00155                 new->data.flag.pflag = pflag; new->data.flag.value = value);
00156   return id;
00157 }

int eventq_remove (  EVENTQ_ID_TYPE    id ) 
 

Definition at line 243 of file eventq.c.

References EVENTQ_ID_TYPE, FALSE, eventq_desc::id, eventq_desc::next, and TRUE. 

00244 {
00245   struct eventq_desc *prev, *ev;
00246 
00247   for (prev=NULL,ev=eventq_pending; ev; prev=ev,ev=ev->next)
00248     {
00249       if (ev->id == id)
00250         {
00251           if (prev)
00252             {
00253               /* middle of end of list */
00254               prev->next = ev->next;
00255             }
00256           else /* !prev */
00257             {
00258               /* beginning of list */
00259               eventq_pending = ev->next;
00260             }
00261 
00262           /* put event on free list */
00263           ev->next = eventq_free;
00264           eventq_free = ev;
00265 
00266           /* return success */
00267           return TRUE;
00268         }
00269     }
00270   /* not found */
00271   return FALSE;
00272 }

void eventq_service_events (  SS_TIME_TYPE    now ) 
 

Definition at line 275 of file eventq.c.

References EXECUTE_ACTION, eventq_desc::next, and eventq_desc::when. 

00276 {
00277   while (eventq_pending && eventq_pending->when <= now)
00278     {
00279       struct eventq_desc *ev = eventq_pending;
00280 
00281       /* handle action */
00282       EXECUTE_ACTION(ev, now);
00283 
00284       /* return the event record to the free list */
00285       eventq_pending = ev->next;
00286       ev->next = eventq_free;
00287       eventq_free = ev;
00288   }
00289 }

Variable Documentation

int eventq_event_count
 

Definition at line 81 of file eventq.c.

Referenced by eventq_init().

struct eventq_desc* eventq_free
 

Definition at line 83 of file eventq.c.

int eventq_max_events
 

Definition at line 80 of file eventq.c.

Referenced by eventq_init().

struct eventq_desc* eventq_pending
 

Definition at line 82 of file eventq.c.

EVENTQ_ID_TYPE next_ID = 1 [static]
 

Definition at line 85 of file eventq.c.


UVa CS Department of Computer Science
School of Engineering, University of Virginia
151 Engineer's Way, P.O. Box 400740
Charlottesville, Virginia 22904-4740
(434) 982-2200  Fax: (434) 982-2214