sim/common/sim-events.h

   1 /*  This file is part of the program psim.
   2
   3     Copyright (C) 1994-1997, Andrew Cagney <cagney@highland.com.au>
   4
   5     This program is free software; you can redistribute it and/or modify
   6     it under the terms of the GNU General Public License as published by
   7     the Free Software Foundation; either version 2 of the License, or
   8     (at your option) any later version.
   9
  10     This program is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13     GNU General Public License for more details.
  14
  15     You should have received a copy of the GNU General Public License
  16     along with this program; if not, write to the Free Software
  17     Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18
  19     */
  20
  21
  22 #ifndef _SIM_EVENTS_H_
  23 #define _SIM_EVENTS_H_
  24
  25
  26 /* Notes:
  27
  28    When scheduling an event, the a delta of zero/one refers to the
  29    timeline as follows:
  30
  31    epoch   0|1              1|2              2|3              3|
  32    **queue**|--insn--|*queue*|--insn--|*queue*|--insn--|*queue*|
  33      |   ^               ^        |       ^                ^
  34      `- +0 ------------ +1 --..   `----- +0 ------------- +1 --..
  35
  36    When the queue is initialized, the time is set to zero with a
  37    number of initialization events scheduled.  Consequently, as also
  38    illustrated above, the event queue should be processed before the
  39    first instruction.  That instruction being executed during tick 1.
  40
  41    The simulator main loop may take a form similar to:
  42
  43        if (halt-/restart-setjmp)
  44          {
  45
  46            .... // Determine who should go next
  47            last-cpu-nr = get-last-cpu-nr (sd);
  48            next-cpu-nr = get-next-cpu-nr (sd);
  49            events-were-last? = (last-cpu-nr >= nr-cpus);
  50            events-were-next? = (next-cpu-nr >= nr-cpus);
  51
  52            .... // process any outstanding events
  53            sim_events_preprocess (sd, events-were-last?, events-were-next?);
  54            if (events-were-next)
  55              next-cpu-nr = 0;
  56
  57            .... // prime main loop
  58
  59            while (1)
  60              {
  61                 .... // model one insn of next-cpu-nr .. nr-cpus
  62                 if (sim_events_tick (sd))
  63                   sim_events_process (sd);
  64                 next-cpu-nr = 0
  65              }
  66          }
  67
  68    NB.  In the above pseudo code it is assumed that any cpu-nr >=
  69    nr-cpus is a marker for the event queue. */
  70
  71
  72 typedef void sim_event_handler(SIM_DESC sd, void *data);
  73
  74 typedef struct _sim_event sim_event;
  75
  76 typedef struct _sim_events sim_events;
  77 struct _sim_events {
  78   int nr_ticks_to_process;
  79   sim_event *queue;
  80   sim_event *watchpoints;
  81   sim_event *watchedpoints;
  82   sim_event *free_list;
  83   /* flag additional work needed */
  84   volatile int work_pending;
  85   /* the asynchronous event queue */
  86 #ifndef MAX_NR_SIGNAL_SIM_EVENTS
  87 #define MAX_NR_SIGNAL_SIM_EVENTS 2
  88 #endif
  89   sim_event *held;
  90   volatile int nr_held;
  91   /* timekeeping */
  92   SIM_ELAPSED_TIME initial_wallclock;
  93   signed64 time_of_event;
  94   int time_from_event;
  95   int trace;
  96 };
  97
  98
  99
 100 /* Install the "events" module.  */
 101
 102 EXTERN_SIM_EVENTS\
 103 (SIM_RC) sim_events_install (SIM_DESC sd);
 104
 105
 106 /* Uninstall the "events" subsystem.  */
 107
 108 EXTERN_SIM_EVENTS\
 109 (void)
 110 sim_events_uninstall (SIM_DESC sd);
 111
 112
 113
 114 /* Initialization */
 115
 116 EXTERN_SIM_EVENTS\
 117 (SIM_RC) sim_events_init (SIM_DESC sd);
 118
 119
 120 /* Set Tracing Level */
 121
 122 EXTERN_SIM_EVENTS\
 123 (void) sim_events_set_trace
 124 (SIM_DESC sd,
 125  int level);
 126
 127
 128 /* Schedule an event DELTA_TIME ticks into the future */
 129
 130 EXTERN_SIM_EVENTS\
 131 (sim_event *) sim_events_schedule
 132 (SIM_DESC sd,
 133  signed64 delta_time,
 134  sim_event_handler *handler,
 135  void *data);
 136
 137 EXTERN_SIM_EVENTS\
 138 (void) sim_events_schedule_after_signal
 139 (SIM_DESC sd,
 140  signed64 delta_time,
 141  sim_event_handler *handler,
 142  void *data);
 143
 144
 145 /* Schedule an event milli-seconds from NOW.  The exact interpretation
 146    of wallclock is host dependant. */
 147
 148 EXTERN_SIM_EVENTS\
 149 (sim_event *) sim_events_watch_clock
 150 (SIM_DESC sd,
 151  unsigned delta_ms_time,
 152  sim_event_handler *handler,
 153  void *data);
 154
 155
 156 /* Schedule an event when the NR_BYTES value at HOST_ADDR with
 157    BYTE_ORDER lies within LB..UB (unsigned).
 158
 159    HOST_ADDR: pointer into the host address space.
 160    BYTE_ORDER: 0 - host endian; BIG_ENDIAN; LITTLE_ENDIAN */
 161
 162 EXTERN_SIM_EVENTS\
 163 (sim_event*) sim_events_watch_sim
 164 (SIM_DESC sd,
 165  void *host_addr,
 166  int nr_bytes,
 167  int byte_order,
 168  unsigned64 lb,
 169  unsigned64 ub,
 170  sim_event_handler *handler,
 171  void *data);
 172
 173
 174 /* Schedule an event when the NR_BYTES value at CORE_ADDR with BYTE_ORDER
 175    lies between LB..UB.
 176
 177    CORE_ADDR/MAP: pointer into the target address space.
 178    BYTE_ORDER: 0 - current target endian; BIG_ENDIAN; LITTLE_ENDIAN */
 179
 180 EXTERN_SIM_EVENTS\
 181 (sim_event*) sim_events_watch_core
 182 (SIM_DESC sd,
 183  address_word core_addr,
 184  sim_core_maps core_map,
 185  int nr_bytes,
 186  int byte_order,
 187  unsigned64 lb,
 188  unsigned64 ub,
 189  sim_event_handler *handler,
 190  void *data);
 191
 192 /* Deschedule the specified event */
 193
 194 EXTERN_SIM_EVENTS\
 195 (void) sim_events_deschedule
 196 (SIM_DESC sd,
 197  sim_event *event_to_remove);
 198
 199
 200 /* Prepare for main simulator loop.  Ensure that the next thing to do
 201    is not event processing.
 202
 203    If the simulator halted part way through event processing then both
 204    EVENTS_WERE_LAST and EVENTS_WERE_FIRST shall be true.
 205
 206    If the simulator halted after processing the last cpu, then only
 207    EVENTS_WERE_NEXT shall be true. */
 208
 209 INLINE_SIM_EVENTS\
 210 (void) sim_events_preprocess
 211 (SIM_DESC sd,
 212  int events_were_last,
 213  int events_were_next);
 214
 215
 216 /* Progress time - separated into two parts so that the main loop can
 217    save its context before the event queue is processed.
 218
 219    sim_events_tickn advances the clock by N cycles. */
 220
 221 INLINE_SIM_EVENTS\
 222 (int) sim_events_tick
 223 (SIM_DESC sd);
 224
 225 INLINE_SIM_EVENTS\
 226 (int) sim_events_tickn
 227 (SIM_DESC sd,
 228  unsigned n);
 229
 230 INLINE_SIM_EVENTS\
 231 (void) sim_events_process
 232 (SIM_DESC sd);
 233
 234
 235 /* Progress time such that an event shall occure upon the next call to
 236    sim_events tick */
 237
 238 #if 0
 239 INLINE_SIM_EVENTS\
 240 (void) sim_events_timewarp
 241 (SIM_DESC sd);
 242 #endif
 243
 244
 245 /* local concept of time */
 246
 247 INLINE_SIM_EVENTS\
 248 (signed64) sim_events_time
 249 (SIM_DESC sd);
 250
 251
 252 #endif