src/sim/eventq.cc - testing/jenkins-gem5-prod - Git at Google

 /*
  * Copyright (c) 2000-2005 The Regents of The University of Michigan
  * Copyright (c) 2008 The Hewlett-Packard Development Company
  * Copyright (c) 2013 Advanced Micro Devices, Inc.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met: redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer;
  * redistributions in binary form must reproduce the above copyright
  * notice, this list of conditions and the following disclaimer in the
  * documentation and/or other materials provided with the distribution;
  * neither the name of the copyright holders nor the names of its
  * contributors may be used to endorse or promote products derived from
  * this software without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * Authors: Steve Reinhardt
  *          Nathan Binkert
  *          Steve Raasch
  */

 #include <cassert>
 #include <iostream>
 #include <string>
 #include <unordered_map>
 #include <vector>

 #include "base/misc.hh"
 #include "base/trace.hh"
 #include "cpu/smt.hh"
 #include "debug/Checkpoint.hh"
 #include "sim/core.hh"
 #include "sim/eventq_impl.hh"

 using namespace std;

 Tick simQuantum = 0;

 //
 // Main Event Queues
 //
 // Events on these queues are processed at the *beginning* of each
 // cycle, before the pipeline simulation is performed.
 //
 uint32_t numMainEventQueues = 0;
 vector<EventQueue *> mainEventQueue;
 __thread EventQueue *_curEventQueue = NULL;
 bool inParallelMode = false;

 EventQueue *
 getEventQueue(uint32_t index)
 {
     while (numMainEventQueues <= index) {
         numMainEventQueues++;
         mainEventQueue.push_back(
             new EventQueue(csprintf("MainEventQueue-%d", index)));
     }

     return mainEventQueue[index];
 }

 #ifndef NDEBUG
 Counter Event::instanceCounter = 0;
 #endif

 Event::~Event()
 {
     assert(!scheduled());
     flags = 0;
 }

 const std::string
 Event::name() const
 {
 #ifndef NDEBUG
     return csprintf("Event_%d", instance);
 #else
     return csprintf("Event_%x", (uintptr_t)this);
 #endif
 }


 Event *
 Event::insertBefore(Event *event, Event *curr)
 {
     // Either way, event will be the top element in the 'in bin' list
     // which is the pointer we need in order to look into the list, so
     // we need to insert that into the bin list.
     if (!curr || *event < *curr) {
         // Insert the event before the current list since it is in the future.
         event->nextBin = curr;
         event->nextInBin = NULL;
     } else {
         // Since we're on the correct list, we need to point to the next list
         event->nextBin = curr->nextBin;  // curr->nextBin can now become stale

         // Insert event at the top of the stack
         event->nextInBin = curr;
     }

     return event;
 }

 void
 EventQueue::insert(Event *event)
 {
     // Deal with the head case
     if (!head || *event <= *head) {
         head = Event::insertBefore(event, head);
         return;
     }

     // Figure out either which 'in bin' list we are on, or where a new list
     // needs to be inserted
     Event *prev = head;
     Event *curr = head->nextBin;
     while (curr && *curr < *event) {
         prev = curr;
         curr = curr->nextBin;
     }

     // Note: this operation may render all nextBin pointers on the
     // prev 'in bin' list stale (except for the top one)
     prev->nextBin = Event::insertBefore(event, curr);
 }

 Event *
 Event::removeItem(Event *event, Event *top)
 {
     Event *curr = top;
     Event *next = top->nextInBin;

     // if we removed the top item, we need to handle things specially
     // and just remove the top item, fixing up the next bin pointer of
     // the new top item
     if (event == top) {
         if (!next)
             return top->nextBin;
         next->nextBin = top->nextBin;
         return next;
     }

     // Since we already checked the current element, we're going to
     // keep checking event against the next element.
     while (event != next) {
         if (!next)
             panic("event not found!");

         curr = next;
         next = next->nextInBin;
     }

     // remove next from the 'in bin' list since it's what we're looking for
     curr->nextInBin = next->nextInBin;
     return top;
 }

 void
 EventQueue::remove(Event *event)
 {
     if (head == NULL)
         panic("event not found!");

     assert(event->queue == this);

     // deal with an event on the head's 'in bin' list (event has the same
     // time as the head)
     if (*head == *event) {
         head = Event::removeItem(event, head);
         return;
     }

     // Find the 'in bin' list that this event belongs on
     Event *prev = head;
     Event *curr = head->nextBin;
     while (curr && *curr < *event) {
         prev = curr;
         curr = curr->nextBin;
     }

     if (!curr || *curr != *event)
         panic("event not found!");

     // curr points to the top item of the the correct 'in bin' list, when
     // we remove an item, it returns the new top item (which may be
     // unchanged)
     prev->nextBin = Event::removeItem(event, curr);
 }

 Event *
 EventQueue::serviceOne()
 {
     std::lock_guard<EventQueue> lock(*this);
     Event *event = head;
     Event *next = head->nextInBin;
     event->flags.clear(Event::Scheduled);

     if (next) {
         // update the next bin pointer since it could be stale
         next->nextBin = head->nextBin;

         // pop the stack
         head = next;
     } else {
         // this was the only element on the 'in bin' list, so get rid of
         // the 'in bin' list and point to the next bin list
         head = head->nextBin;
     }

     // handle action
     if (!event->squashed()) {
         // forward current cycle to the time when this event occurs.
         setCurTick(event->when());

         event->process();
         if (event->isExitEvent()) {
             assert(!event->flags.isSet(Event::AutoDelete) ||
                    !event->flags.isSet(Event::IsMainQueue)); // would be silly
             return event;
         }
     } else {
         event->flags.clear(Event::Squashed);
     }

     if (event->flags.isSet(Event::AutoDelete) && !event->scheduled())
         delete event;

     return NULL;
 }

 void
 Event::serialize(CheckpointOut &cp) const
 {
     SERIALIZE_SCALAR(_when);
     SERIALIZE_SCALAR(_priority);
     short _flags = flags;
     SERIALIZE_SCALAR(_flags);
 }

 void
 Event::unserialize(CheckpointIn &cp)
 {
     assert(!scheduled());

     UNSERIALIZE_SCALAR(_when);
     UNSERIALIZE_SCALAR(_priority);

     FlagsType _flags;
     UNSERIALIZE_SCALAR(_flags);

     // Old checkpoints had no concept of the Initialized flag
     // so restoring from old checkpoints always fail.
     // Events are initialized on construction but original code
     // "flags = _flags" would just overwrite the initialization.
     // So, read in the checkpoint flags, but then set the Initialized
     // flag on top of it in order to avoid failures.
     assert(initialized());
     flags = _flags;
     flags.set(Initialized);

     // need to see if original event was in a scheduled, unsquashed
     // state, but don't want to restore those flags in the current
     // object itself (since they aren't immediately true)
     if (flags.isSet(Scheduled) && !flags.isSet(Squashed)) {
         flags.clear(Squashed | Scheduled);
     } else {
         DPRINTF(Checkpoint, "Event '%s' need to be scheduled @%d\n",
                 name(), _when);
     }
 }

 void
 EventQueue::checkpointReschedule(Event *event)
 {
     // It's safe to call insert() directly here since this method
     // should only be called when restoring from a checkpoint (which
     // happens before thread creation).
     if (event->flags.isSet(Event::Scheduled))
         insert(event);
 }
 void
 EventQueue::dump() const
 {
     cprintf("============================================================\n");
     cprintf("EventQueue Dump  (cycle %d)\n", curTick());
     cprintf("------------------------------------------------------------\n");

     if (empty())
         cprintf("<No Events>\n");
     else {
         Event *nextBin = head;
         while (nextBin) {
             Event *nextInBin = nextBin;
             while (nextInBin) {
                 nextInBin->dump();
                 nextInBin = nextInBin->nextInBin;
             }

             nextBin = nextBin->nextBin;
         }
     }

     cprintf("============================================================\n");
 }

 bool
 EventQueue::debugVerify() const
 {
     std::unordered_map<long, bool> map;

     Tick time = 0;
     short priority = 0;

     Event *nextBin = head;
     while (nextBin) {
         Event *nextInBin = nextBin;
         while (nextInBin) {
             if (nextInBin->when() < time) {
                 cprintf("time goes backwards!");
                 nextInBin->dump();
                 return false;
             } else if (nextInBin->when() == time &&
                        nextInBin->priority() < priority) {
                 cprintf("priority inverted!");
                 nextInBin->dump();
                 return false;
             }

             if (map[reinterpret_cast<long>(nextInBin)]) {
                 cprintf("Node already seen");
                 nextInBin->dump();
                 return false;
             }
             map[reinterpret_cast<long>(nextInBin)] = true;

             time = nextInBin->when();
             priority = nextInBin->priority();

             nextInBin = nextInBin->nextInBin;
         }

         nextBin = nextBin->nextBin;
     }

     return true;
 }

 Event*
 EventQueue::replaceHead(Event* s)
 {
     Event* t = head;
     head = s;
     return t;
 }

 void
 dumpMainQueue()
 {
     for (uint32_t i = 0; i < numMainEventQueues; ++i) {
         mainEventQueue[i]->dump();
     }
 }


 const char *
 Event::description() const
 {
     return "generic";
 }

 void
 Event::trace(const char *action)
 {
     // This DPRINTF is unconditional because calls to this function
     // are protected by an 'if (DTRACE(Event))' in the inlined Event
     // methods.
     //
     // This is just a default implementation for derived classes where
     // it's not worth doing anything special.  If you want to put a
     // more informative message in the trace, override this method on
     // the particular subclass where you have the information that
     // needs to be printed.
     DPRINTFN("%s event %s @ %d\n", description(), action, when());
 }

 void
 Event::dump() const
 {
     cprintf("Event %s (%s)\n", name(), description());
     cprintf("Flags: %#x\n", flags);
 #ifdef EVENTQ_DEBUG
     cprintf("Created: %d\n", whenCreated);
 #endif
     if (scheduled()) {
 #ifdef EVENTQ_DEBUG
         cprintf("Scheduled at  %d\n", whenScheduled);
 #endif
         cprintf("Scheduled for %d, priority %d\n", when(), _priority);
     } else {
         cprintf("Not Scheduled\n");
     }
 }

 EventQueue::EventQueue(const string &n)
     : objName(n), head(NULL), _curTick(0)
 {
 }

 void
 EventQueue::asyncInsert(Event *event)
 {
     async_queue_mutex.lock();
     async_queue.push_back(event);
     async_queue_mutex.unlock();
 }

 void
 EventQueue::handleAsyncInsertions()
 {
     assert(this == curEventQueue());
     async_queue_mutex.lock();

     while (!async_queue.empty()) {
         insert(async_queue.front());
         async_queue.pop_front();
     }

     async_queue_mutex.unlock();
 }
	/*
	* Copyright (c) 2000-2005 The Regents of The University of Michigan
	* Copyright (c) 2008 The Hewlett-Packard Development Company
	* Copyright (c) 2013 Advanced Micro Devices, Inc.
	* All rights reserved.
	*
	* Redistribution and use in source and binary forms, with or without
	* modification, are permitted provided that the following conditions are
	* met: redistributions of source code must retain the above copyright
	* notice, this list of conditions and the following disclaimer;
	* redistributions in binary form must reproduce the above copyright
	* notice, this list of conditions and the following disclaimer in the
	* documentation and/or other materials provided with the distribution;
	* neither the name of the copyright holders nor the names of its
	* contributors may be used to endorse or promote products derived from
	* this software without specific prior written permission.
	*
	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
	* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
	* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
	* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	*
	* Authors: Steve Reinhardt
	* Nathan Binkert
	* Steve Raasch
	*/

	#include <cassert>
	#include <iostream>
	#include <string>
	#include <unordered_map>
	#include <vector>

	#include "base/misc.hh"
	#include "base/trace.hh"
	#include "cpu/smt.hh"
	#include "debug/Checkpoint.hh"
	#include "sim/core.hh"
	#include "sim/eventq_impl.hh"

	using namespace std;

	Tick simQuantum = 0;

	//
	// Main Event Queues
	//
	// Events on these queues are processed at the beginning of each
	// cycle, before the pipeline simulation is performed.
	//
	uint32_t numMainEventQueues = 0;
	vector<EventQueue *> mainEventQueue;
	__thread EventQueue *_curEventQueue = NULL;
	bool inParallelMode = false;

	EventQueue *
	getEventQueue(uint32_t index)
	{
	while (numMainEventQueues <= index) {
	numMainEventQueues++;
	mainEventQueue.push_back(
	new EventQueue(csprintf("MainEventQueue-%d", index)));
	}

	return mainEventQueue[index];
	}

	#ifndef NDEBUG
	Counter Event::instanceCounter = 0;
	#endif

	Event::~Event()
	{
	assert(!scheduled());
	flags = 0;
	}

	const std::string
	Event::name() const
	{
	#ifndef NDEBUG
	return csprintf("Event_%d", instance);
	#else
	return csprintf("Event_%x", (uintptr_t)this);
	#endif
	}


	Event *
	Event::insertBefore(Event event, Event curr)
	{
	// Either way, event will be the top element in the 'in bin' list
	// which is the pointer we need in order to look into the list, so
	// we need to insert that into the bin list.
	if (!curr \|\| event < curr) {
	// Insert the event before the current list since it is in the future.
	event->nextBin = curr;
	event->nextInBin = NULL;
	} else {
	// Since we're on the correct list, we need to point to the next list
	event->nextBin = curr->nextBin; // curr->nextBin can now become stale

	// Insert event at the top of the stack
	event->nextInBin = curr;
	}

	return event;
	}

	void
	EventQueue::insert(Event *event)
	{
	// Deal with the head case
	if (!head \|\| event <= head) {
	head = Event::insertBefore(event, head);
	return;
	}

	// Figure out either which 'in bin' list we are on, or where a new list
	// needs to be inserted
	Event *prev = head;
	Event *curr = head->nextBin;
	while (curr && curr < event) {
	prev = curr;
	curr = curr->nextBin;
	}

	// Note: this operation may render all nextBin pointers on the
	// prev 'in bin' list stale (except for the top one)
	prev->nextBin = Event::insertBefore(event, curr);
	}

	Event *
	Event::removeItem(Event event, Event top)
	{
	Event *curr = top;
	Event *next = top->nextInBin;

	// if we removed the top item, we need to handle things specially
	// and just remove the top item, fixing up the next bin pointer of
	// the new top item
	if (event == top) {
	if (!next)
	return top->nextBin;
	next->nextBin = top->nextBin;
	return next;
	}

	// Since we already checked the current element, we're going to
	// keep checking event against the next element.
	while (event != next) {
	if (!next)
	panic("event not found!");

	curr = next;
	next = next->nextInBin;
	}

	// remove next from the 'in bin' list since it's what we're looking for
	curr->nextInBin = next->nextInBin;
	return top;
	}

	void
	EventQueue::remove(Event *event)
	{
	if (head == NULL)
	panic("event not found!");

	assert(event->queue == this);

	// deal with an event on the head's 'in bin' list (event has the same
	// time as the head)
	if (head == event) {
	head = Event::removeItem(event, head);
	return;
	}

	// Find the 'in bin' list that this event belongs on
	Event *prev = head;
	Event *curr = head->nextBin;
	while (curr && curr < event) {
	prev = curr;
	curr = curr->nextBin;
	}

	if (!curr \|\| curr != event)
	panic("event not found!");

	// curr points to the top item of the the correct 'in bin' list, when
	// we remove an item, it returns the new top item (which may be
	// unchanged)
	prev->nextBin = Event::removeItem(event, curr);
	}

	Event *
	EventQueue::serviceOne()
	{
	std::lock_guard<EventQueue> lock(*this);
	Event *event = head;
	Event *next = head->nextInBin;
	event->flags.clear(Event::Scheduled);

	if (next) {
	// update the next bin pointer since it could be stale
	next->nextBin = head->nextBin;

	// pop the stack
	head = next;
	} else {
	// this was the only element on the 'in bin' list, so get rid of
	// the 'in bin' list and point to the next bin list
	head = head->nextBin;
	}

	// handle action
	if (!event->squashed()) {
	// forward current cycle to the time when this event occurs.
	setCurTick(event->when());

	event->process();
	if (event->isExitEvent()) {
	assert(!event->flags.isSet(Event::AutoDelete) \|\|
	!event->flags.isSet(Event::IsMainQueue)); // would be silly
	return event;
	}
	} else {
	event->flags.clear(Event::Squashed);
	}

	if (event->flags.isSet(Event::AutoDelete) && !event->scheduled())
	delete event;

	return NULL;
	}

	void
	Event::serialize(CheckpointOut &cp) const
	{
	SERIALIZE_SCALAR(_when);
	SERIALIZE_SCALAR(_priority);
	short _flags = flags;
	SERIALIZE_SCALAR(_flags);
	}

	void
	Event::unserialize(CheckpointIn &cp)
	{
	assert(!scheduled());

	UNSERIALIZE_SCALAR(_when);
	UNSERIALIZE_SCALAR(_priority);

	FlagsType _flags;
	UNSERIALIZE_SCALAR(_flags);

	// Old checkpoints had no concept of the Initialized flag
	// so restoring from old checkpoints always fail.
	// Events are initialized on construction but original code
	// "flags = _flags" would just overwrite the initialization.
	// So, read in the checkpoint flags, but then set the Initialized
	// flag on top of it in order to avoid failures.
	assert(initialized());
	flags = _flags;
	flags.set(Initialized);

	// need to see if original event was in a scheduled, unsquashed
	// state, but don't want to restore those flags in the current
	// object itself (since they aren't immediately true)
	if (flags.isSet(Scheduled) && !flags.isSet(Squashed)) {
	flags.clear(Squashed \| Scheduled);
	} else {
	DPRINTF(Checkpoint, "Event '%s' need to be scheduled @%d\n",
	name(), _when);
	}
	}

	void
	EventQueue::checkpointReschedule(Event *event)
	{
	// It's safe to call insert() directly here since this method
	// should only be called when restoring from a checkpoint (which
	// happens before thread creation).
	if (event->flags.isSet(Event::Scheduled))
	insert(event);
	}
	void
	EventQueue::dump() const
	{
	cprintf("============================================================\n");
	cprintf("EventQueue Dump (cycle %d)\n", curTick());
	cprintf("------------------------------------------------------------\n");

	if (empty())
	cprintf("<No Events>\n");
	else {
	Event *nextBin = head;
	while (nextBin) {
	Event *nextInBin = nextBin;
	while (nextInBin) {
	nextInBin->dump();
	nextInBin = nextInBin->nextInBin;
	}

	nextBin = nextBin->nextBin;
	}
	}

	cprintf("============================================================\n");
	}

	bool
	EventQueue::debugVerify() const
	{
	std::unordered_map<long, bool> map;

	Tick time = 0;
	short priority = 0;

	Event *nextBin = head;
	while (nextBin) {
	Event *nextInBin = nextBin;
	while (nextInBin) {
	if (nextInBin->when() < time) {
	cprintf("time goes backwards!");
	nextInBin->dump();
	return false;
	} else if (nextInBin->when() == time &&
	nextInBin->priority() < priority) {
	cprintf("priority inverted!");
	nextInBin->dump();
	return false;
	}

	if (map[reinterpret_cast<long>(nextInBin)]) {
	cprintf("Node already seen");
	nextInBin->dump();
	return false;
	}
	map[reinterpret_cast<long>(nextInBin)] = true;

	time = nextInBin->when();
	priority = nextInBin->priority();

	nextInBin = nextInBin->nextInBin;
	}

	nextBin = nextBin->nextBin;
	}

	return true;
	}

	Event*
	EventQueue::replaceHead(Event* s)
	{
	Event* t = head;
	head = s;
	return t;
	}

	void
	dumpMainQueue()
	{
	for (uint32_t i = 0; i < numMainEventQueues; ++i) {
	mainEventQueue[i]->dump();
	}
	}


	const char *
	Event::description() const
	{
	return "generic";
	}

	void
	Event::trace(const char *action)
	{
	// This DPRINTF is unconditional because calls to this function
	// are protected by an 'if (DTRACE(Event))' in the inlined Event
	// methods.
	//
	// This is just a default implementation for derived classes where
	// it's not worth doing anything special. If you want to put a
	// more informative message in the trace, override this method on
	// the particular subclass where you have the information that
	// needs to be printed.
	DPRINTFN("%s event %s @ %d\n", description(), action, when());
	}

	void
	Event::dump() const
	{
	cprintf("Event %s (%s)\n", name(), description());
	cprintf("Flags: %#x\n", flags);
	#ifdef EVENTQ_DEBUG
	cprintf("Created: %d\n", whenCreated);
	#endif
	if (scheduled()) {
	#ifdef EVENTQ_DEBUG
	cprintf("Scheduled at %d\n", whenScheduled);
	#endif
	cprintf("Scheduled for %d, priority %d\n", when(), _priority);
	} else {
	cprintf("Not Scheduled\n");
	}
	}

	EventQueue::EventQueue(const string &n)
	: objName(n), head(NULL), _curTick(0)
	{
	}

	void
	EventQueue::asyncInsert(Event *event)
	{
	async_queue_mutex.lock();
	async_queue.push_back(event);
	async_queue_mutex.unlock();
	}

	void
	EventQueue::handleAsyncInsertions()
	{
	assert(this == curEventQueue());
	async_queue_mutex.lock();

	while (!async_queue.empty()) {
	insert(async_queue.front());
	async_queue.pop_front();
	}

	async_queue_mutex.unlock();
	}