1 /* This file is part of the program psim.
3 Copyright (C) 1994-1998, Andrew Cagney <cagney@highland.com.au>
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.
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.
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.
30 #if !defined (SIM_EVENTS_POLL_RATE)
31 #define SIM_EVENTS_POLL_RATE 0x1000
36 /* The event queue maintains a single absolute time using two
39 TIME_OF_EVENT: this holds the time at which the next event is ment
40 to occure. If no next event it will hold the time of the last
43 TIME_FROM_EVENT: The current distance from TIME_OF_EVENT. If an
44 event is pending, this will be positive. If no future event is
45 pending this will be negative. This variable is decremented once
46 for each iteration of a clock cycle.
48 Initially, the clock is started at time one (1) with TIME_OF_EVENT
49 == 0 and TIME_FROM_EVENT == -1.
51 Clearly there is a bug in that this code assumes that the absolute
52 time counter will never become greater than 2^62. */
54 typedef struct _event_entry event_entry;
57 event_handler *handler;
58 signed64 time_of_event;
65 event_entry *volatile held;
66 event_entry *volatile *volatile held_end;
67 signed64 time_of_event;
68 signed64 time_from_event;
74 sim_events_poll (void *data)
76 event_queue *queue = data;
77 /* just re-schedule in 1000 million ticks time */
78 event_queue_schedule (queue, SIM_EVENTS_POLL_RATE, sim_events_poll, queue);
85 event_queue_create(void)
87 event_queue *new_event_queue = ZALLOC(event_queue);
89 new_event_queue->processing = 0;
90 new_event_queue->queue = NULL;
91 new_event_queue->held = NULL;
92 new_event_queue->held_end = &new_event_queue->held;
94 /* both times are already zero */
95 return new_event_queue;
101 event_queue_init(event_queue *queue)
105 /* drain the interrupt queue */
107 #if defined(HAVE_SIGPROCMASK) && defined(SIG_SETMASK)
110 sigfillset(&new_mask);
111 /*-LOCK-*/ sigprocmask(SIG_SETMASK, &new_mask, &old_mask);
114 while (event != NULL) {
115 event_entry *dead = event;
120 queue->held_end = &queue->held;
121 #if defined(HAVE_SIGPROCMASK) && defined(SIG_SETMASK)
122 /*-UNLOCK-*/ sigprocmask(SIG_SETMASK, &old_mask, NULL);
126 /* drain the normal queue */
127 event = queue->queue;
128 while (event != NULL) {
129 event_entry *dead = event;
135 /* wind time back to one */
136 queue->processing = 0;
137 queue->time_of_event = 0;
138 queue->time_from_event = -1;
140 /* schedule our initial counter event */
141 event_queue_schedule (queue, 0, sim_events_poll, queue);
146 event_queue_time(event_queue *queue)
148 return queue->time_of_event - queue->time_from_event;
151 STATIC_INLINE_EVENTS\
153 update_time_from_event(event_queue *events)
155 signed64 current_time = event_queue_time(events);
156 if (events->queue != NULL) {
157 events->time_from_event = (events->queue->time_of_event - current_time);
158 events->time_of_event = events->queue->time_of_event;
161 events->time_of_event = current_time - 1;
162 events->time_from_event = -1;
164 ASSERT(current_time == event_queue_time(events));
165 ASSERT((events->time_from_event >= 0) == (events->queue != NULL));
168 STATIC_INLINE_EVENTS\
170 insert_event_entry(event_queue *events,
171 event_entry *new_event,
176 signed64 time_of_event;
179 error("what is past is past!\n");
181 /* compute when the event should occure */
182 time_of_event = event_queue_time(events) + delta;
184 /* find the queue insertion point - things are time ordered */
185 prev = &events->queue;
186 curr = events->queue;
187 while (curr != NULL && time_of_event >= curr->time_of_event) {
188 ASSERT(curr->next == NULL
189 || curr->time_of_event <= curr->next->time_of_event);
193 ASSERT(curr == NULL || time_of_event < curr->time_of_event);
196 new_event->next = curr;
198 new_event->time_of_event = time_of_event;
200 /* adjust the time until the first event */
201 update_time_from_event(events);
206 event_queue_schedule(event_queue *events,
208 event_handler *handler,
211 event_entry *new_event = ZALLOC(event_entry);
212 new_event->data = data;
213 new_event->handler = handler;
214 insert_event_entry(events, new_event, delta_time);
215 TRACE(trace_events, ("event scheduled at %ld - tag 0x%lx - time %ld, handler 0x%lx, data 0x%lx\n",
216 (long)event_queue_time(events),
218 (long)new_event->time_of_event,
219 (long)new_event->handler,
220 (long)new_event->data));
221 return (event_entry_tag)new_event;
227 event_queue_schedule_after_signal(event_queue *events,
229 event_handler *handler,
232 event_entry *new_event = ZALLOC(event_entry);
234 new_event->data = data;
235 new_event->handler = handler;
236 new_event->time_of_event = delta_time; /* work it out later */
237 new_event->next = NULL;
240 #if defined(HAVE_SIGPROCMASK) && defined(SIG_SETMASK)
243 sigfillset(&new_mask);
244 /*-LOCK-*/ sigprocmask(SIG_SETMASK, &new_mask, &old_mask);
246 if (events->held == NULL) {
247 events->held = new_event;
250 *events->held_end = new_event;
252 events->held_end = &new_event->next;
253 #if defined(HAVE_SIGPROCMASK) && defined(SIG_SETMASK)
254 /*-UNLOCK-*/ sigprocmask(SIG_SETMASK, &old_mask, NULL);
258 TRACE(trace_events, ("event scheduled at %ld - tag 0x%lx - time %ld, handler 0x%lx, data 0x%lx\n",
259 (long)event_queue_time(events),
261 (long)new_event->time_of_event,
262 (long)new_event->handler,
263 (long)new_event->data));
265 return (event_entry_tag)new_event;
271 event_queue_deschedule(event_queue *events,
272 event_entry_tag event_to_remove)
274 event_entry *to_remove = (event_entry*)event_to_remove;
275 ASSERT((events->time_from_event >= 0) == (events->queue != NULL));
276 if (event_to_remove != NULL) {
277 event_entry *current;
278 event_entry **ptr_to_current;
279 for (ptr_to_current = &events->queue, current = *ptr_to_current;
280 current != NULL && current != to_remove;
281 ptr_to_current = ¤t->next, current = *ptr_to_current);
282 if (current == to_remove) {
283 *ptr_to_current = current->next;
284 TRACE(trace_events, ("event descheduled at %ld - tag 0x%lx - time %ld, handler 0x%lx, data 0x%lx\n",
285 (long)event_queue_time(events),
286 (long)event_to_remove,
287 (long)current->time_of_event,
288 (long)current->handler,
289 (long)current->data));
291 update_time_from_event(events);
294 TRACE(trace_events, ("event descheduled at %ld - tag 0x%lx - not found\n",
295 (long)event_queue_time(events),
296 (long)event_to_remove));
299 ASSERT((events->time_from_event >= 0) == (events->queue != NULL));
307 event_queue_tick(event_queue *events)
309 signed64 time_from_event;
311 /* we should only be here when the previous tick has been fully processed */
312 ASSERT(!events->processing);
314 /* move any events that were queued by any signal handlers onto the
315 real event queue. BTW: When inlining, having this code here,
316 instead of in event_queue_process() causes GCC to put greater
317 weight on keeping the pointer EVENTS in a register. This, in
318 turn results in better code being output. */
319 if (events->held != NULL) {
320 event_entry *held_events;
321 event_entry *curr_event;
324 #if defined(HAVE_SIGPROCMASK) && defined(SIG_SETMASK)
327 sigfillset(&new_mask);
328 /*-LOCK-*/ sigprocmask(SIG_SETMASK, &new_mask, &old_mask);
330 held_events = events->held;
332 events->held_end = &events->held;
333 #if defined(HAVE_SIGPROCMASK) && defined(SIG_SETMASK)
334 /*-UNLOCK-*/ sigprocmask(SIG_SETMASK, &old_mask, NULL);
339 curr_event = held_events;
340 held_events = curr_event->next;
341 insert_event_entry(events, curr_event, curr_event->time_of_event);
342 } while (held_events != NULL);
345 /* advance time, checking to see if we've reached time zero which
346 would indicate the time for the next event has arrived */
347 time_from_event = events->time_from_event;
348 events->time_from_event = time_from_event - 1;
349 return time_from_event == 0;
356 event_queue_process(event_queue *events)
358 signed64 event_time = event_queue_time(events);
360 ASSERT((events->time_from_event == -1 && events->queue != NULL)
361 || events->processing); /* something to do */
363 /* consume all events for this or earlier times. Be careful to
364 allow a new event to appear under our feet */
365 events->processing = 1;
366 while (events->queue != NULL
367 && events->queue->time_of_event <= event_time) {
368 event_entry *to_do = events->queue;
369 event_handler *handler = to_do->handler;
370 void *data = to_do->data;
371 events->queue = to_do->next;
372 TRACE(trace_events, ("event issued at %ld - tag 0x%lx - handler 0x%lx, data 0x%lx\n",
380 events->processing = 0;
382 /* re-caculate time for new events */
383 update_time_from_event(events);
387 #endif /* _EVENTS_C_ */