src/sim/eventq.hh

61 //! event to scheduled on Queue A which is generated by an event on
65 //! Current number of allocated main event queues.
68 //! Array for main event queues.
71 //! The current event queue for the running thread. Access to this queue
111     static const FlagsType IsExitEvent   = 0x0010; // special exit event
112     static const FlagsType IsMainQueue   = 0x0020; // on main event queue
137     /// CPU switches schedule the new CPU's tick event for the
138     /// same cycle (after unscheduling the old CPU's tick event).
151     /// DVFS update event leads to stats dump therefore given a lower priority
183  * An item on an event queue.  The action caused by a given
184  * event is specified by deriving a subclass and overriding the
194     // The event queue is now a linked list of linked lists.  The
206     static Event *insertBefore(Event *event, Event *curr);
207     static Event *removeItem(Event *event, Event *last);
209     Tick _when;         //!< timestamp when event should be processed
210     Priority _priority; //!< event priority
217     /// This event's unique ID.  We can also use pointer values for
223     /// queue to which this event belongs (though it may or may not be
288     virtual void trace(const char *action);     //!< trace event activity
297      * events once they have been removed from the event queue. This
304      * implementation of the event is kept alive while it lives in the
305      * event queue.
309      * releaseImpl()) or checking if an event is no longer scheduled
314      * Managed event scheduled and being held in the event queue.
323      * Managed event removed from the event queue.
343      * @param queue that the event gets scheduled on
363     /// Return a C string describing the event.  This string should
365     /// describing the event class.
368     /// Dump the current event data
373      * This member function is invoked when the event is processed
375      * must provide its own implementation.  The event is not
377      * statically allocated event objects).
384     /// Determine if the current event is scheduled
387     /// Squash the current event
390     /// Check whether the event is squashed
396     /// Check whether this event will auto-delete
400     /// Get the time that the event is scheduled
403     /// Get the event priority
457  * Events are scheduled (inserted into the event queue) using the
459  * or <i>asynchronous</i> event.
463  * from a thread holding the event queue lock
464  * (EventQueue::service_mutex). The lock is always held when an event
466  * own event queue unless it voluntarily releases the lock.
468  * Events can be scheduled across thread (and event queue borders) by
469  * either scheduling asynchronous events or taking the target event
472  * that needs to schedule events in other event queues should
475  * event queue lock. This functionality is provided by the
477  * between event queues can make the simulation non-deterministic, it
484  * deterministic. This causes the event to be inserted in a separate
486  * event queue at the end of each simulation quantum (by calling the
502     //! List of events added by other threads to this event queue.
506      * Lock protecting event handling.
512      * response to an earlier event.
514      * This lock is intended to be used to temporarily steal an event
527     //! Insert / remove event from the queue. Should only be called
529     void insert(Event *event);
530     void remove(Event *event);
533     //! are added to main event queue later. Threads, other than the
535     void asyncInsert(Event *event);
541      * Temporarily migrate execution to a different event queue.
544      * different event queue by releasing the current queue, locking
546      * example, be useful when performing IO across thread event
582      * Temporarily release the event queue service lock.
585      * the event queue lock to prevent deadlocks. For example, when
588      * temporarily take over the event queue waiting on the barrier.
613     //! Schedule the given event on this queue. Safe to call from any
615     void schedule(Event *event, Tick when, bool global = false);
617     //! Deschedule the specified event. Should be called only from the
619     void deschedule(Event *event);
621     //! Reschedule the specified event. Should be called only from
623     void reschedule(Event *event, Tick when, bool always = false);
646             //assert(head->when() >= when && "event scheduled in the past");
664      *  Function to signal that the event loop should be woken up because
665      *  an event has been scheduled by an agent outside the gem5 event
666      *  loop(s) whose event insertion may not have been noticed by gem5.
667      *  This function isn't needed by the usual gem5 event loop but may
674      *  Or it can be ignored and the event queue can be woken up now.
679      *  function for replacing the head of the event queue, so that a
690      * Provide an interface for locking/unlocking the event queue.
705      * Reschedule an event after a checkpoint.
707      * Since events don't know which event queue they belong to,
709      * method conditionally schedules an event that has the Scheduled
715     void checkpointReschedule(Event *event);
729     /** A pointer to this object's event queue */
744     schedule(Event &event, Tick when)
746         eventq->schedule(&event, when);
750     deschedule(Event &event)
752         eventq->deschedule(&event);
756     reschedule(Event &event, Tick when, bool always = false)
758         eventq->reschedule(&event, when, always);
762     schedule(Event *event, Tick when)
764         eventq->schedule(event, when);
768     deschedule(Event *event)
770         eventq->deschedule(event);
774     reschedule(Event *event, Tick when, bool always = false)
776         eventq->reschedule(event, when, always);