vpr::sim::Controller Class Reference

Socket simulation controller. More...

#include <vpr/md/SIM/Controller.h>

Collaboration diagram for vpr::sim::Controller:

[legend]List of all members.

Public Member Functions
	Controller ()
	Initializes the socket simulation.
	~Controller ()
	Resets the Sim Socket Manager's clock to 0.
vpr::ReturnStatus	constructNetwork (const std::string &graph_file)
void	destroyNetworkGraph ()
bool	isRunning ()
	Queries the running state of this socket simulation.
void	setSimulationPauseTime (const vpr::Uint32 sleep_time)
	Sets the amount of time (in microseconds) to sleep after processing a single event.
void	addMessageEvent (const vpr::Interval &event_time, const NetworkGraph::net_edge_t edge, const NetworkLine::LineDirection dir)
	Adds an event scheduled to occur at the given time to the queue of upcoming events.
void	addConnectionEvent (const vpr::Interval &event_time, vpr::SocketImplSIM *acceptor_sock)
void	addConnectionCompletionEvent (const vpr::Interval &event_time, vpr::SocketImplSIM *connector_sock)
void	addLocalhostDeliveryEvent (const vpr::Interval &event_time, vpr::SocketImplSIM *connector_sock)
void	flushPath (const vpr::SocketImplSIM *sock, vpr::sim::NetworkGraph::VertexListPtr path)
	Flushes all messages (and associated events) on the given path destined for the given socket.
void	processNextEvent (vpr::SocketImplSIM **recvSocket=NULL)
	Processes the next event in the event queue no matter how far into the (simulated) future it occurs.
void	processEvents (const vpr::Interval &time_step)
	Limits the time frame for the occurrence of the next events to the given time step.
vpr::Uint32	getNumPendingEvents ()
	Return the number of events pending in the system.
const vpr::sim::Clock &	getClock () const
vpr::sim::SocketManager &	getSocketManager ()
vpr::sim::NetworkGraph &	getNetworkGraph ()
Static Public Member Functions
static void	setInstance (Controller *c)
	Set the instance to be returned in this thread to the given object pointer.
static Controller *	instance ()
	Returns an instance of this thread-specific singleton class.
Protected Types
typedef std::multimap< vpr::Interval, EventData >	event_map_t
Protected Member Functions
	Controller (const Controller &o)
void	operator= (const Controller &o)
Protected Attributes
vpr::sim::Clock	mClock
	The global clock that we are using.
vpr::sim::SocketManager	mSocketManager
	The socket manager that we are using.
vpr::sim::NetworkGraph	mGraph
	The network graph used for the simulation.
event_map_t	mEvents
vpr::Uint32	mSleepTime
Classes
class	ControllerTS
struct	EventData

---

Detailed Description

Socket simulation controller.

This is used to step through a simulation being controlled by the Sim Socket Manager. This class is a thread-specific singleton so that each running thread can have its own unique instance. It can also be used as a traditional global singleton. To use it as a thread-specific singleton, call setInstance() as the first step of a newly spawned thread. This is crucial to its functionality.

Definition at line 78 of file Controller.h.

---

Member Typedef Documentation

typedef std::multimap<vpr::Interval, EventData> vpr::sim::Controller::event_map_t [protected]

Definition at line 331 of file Controller.h.

---

Constructor & Destructor Documentation

vpr::sim::Controller::Controller

(

)

Initializes the socket simulation.

This should only be called when a thread-specific instance is needed. Otherwise, use the static instance() method to get a thread-specific or global instance depending on what is available.

Postcondition:

An instance of the Sim Socket Manager is retrieved, and the simulation state is set to not started.

Definition at line 69 of file Controller.cpp.

   : mSleepTime(0)
{
   /* Do nothing. */ ;
}

vpr::sim::Controller::~Controller

(

)

[inline]

Resets the Sim Socket Manager's clock to 0.

Postcondition:

The Sim Socket Manager's clock is reset to 0 so that the same instance may be used by another simulation.

Definition at line 98 of file Controller.h.

   {
      /* Do nothing. */ ;
   }

vpr::sim::Controller::Controller

(

const Controller &

o

)

[inline, protected]

Definition at line 277 of file Controller.h.

{;}

---

Member Function Documentation

static void vpr::sim::Controller::setInstance

(

Controller *

c

)

[inline, static]

Set the instance to be returned in this thread to the given object pointer.

This should be done as the first step by all threads wishing to have a thread-specific instance of this singleton class.

Definition at line 108 of file Controller.h.

   {
      mInstance->setObject(c);
   }

static Controller* vpr::sim::Controller::instance

(

)

[inline, static]

Returns an instance of this thread-specific singleton class.

If a thread-specific instance was set by the currently active thread using setInstance(), that instance is returned. If no instance is associated with the current thread, the primordial (global) instance is returned.

Definition at line 119 of file Controller.h.

References vprASSERT.

Referenced by vpr::SocketStreamImplSIM::accept(), vpr::sim::SocketManager::assignToNode(), vpr::SocketImplSIM::bind(), vpr::SocketImplSIM::close(), vpr::sim::SocketManager::connect(), vpr::SocketImplSIM::connect(), vpr::sim::SocketManager::ensureNetworkNodeIsRegistered(), vpr::sim::SocketManager::findRoute(), vpr::SocketStreamImplSIM::listen(), vpr::sim::SocketManager::sendMessage(), vpr::sim::SocketManager::sendMessageTo(), vpr::SocketDatagramImplSIM::sendto(), and vpr::SocketImplSIM::write_i().

   {
      // WARNING! race condition possibility, creation of static vars
      // are not thread safe.  This is only an issue when creating
      // your first thread, since it uses a singleton thread manager,
      // the two threads might both try to call instance at the same time
      // which then the creation of the following mutex would not be certain.
      static vpr::Mutex singleton_lock;

      if ( mInstance->getObject() == NULL )
      {
         vpr::Guard<vpr::Mutex> guard(singleton_lock);

         if ( mPrimordialInstance == NULL )
         {
            mPrimordialInstance = new Controller;
         }

         if ( mInstance->getObject() == NULL )
         {
            mInstance->setObject(mPrimordialInstance);
         }

         vprASSERT(mInstance->getObject() != NULL && "No instance defined");
      }

      return mInstance->getObject();
   }

vpr::ReturnStatus vpr::sim::Controller::constructNetwork

(

const std::string &

graph_file

)

Definition at line 75 of file Controller.cpp.

References vpr::sim::NetworkGraph::clear(), vpr::sim::NetworkGraph::construct(), vpr::sim::NetworkGraph::isValid(), mGraph, mSocketManager, vpr::sim::SocketManager::setActive(), and vpr::ReturnStatus::success().

{
   vpr::ReturnStatus status;

   if ( mGraph.isValid() )
   {
      mGraph.clear();
   }

   status = mGraph.construct(graph_file);

   if ( status.success() )
   {
      mSocketManager.setActive();
   }

   return status;
}

void vpr::sim::Controller::destroyNetworkGraph

(

)

[inline]

Definition at line 150 of file Controller.h.

   {
      mGraph.clear();
   }

bool vpr::sim::Controller::isRunning

(

)

[inline]

Queries the running state of this socket simulation.

The simulation is considered running if it has been started and if the Sim Socket Manager still has active sockets registered.

Postcondition:

The running state of this simulation is returned to the caller.

Definition at line 162 of file Controller.h.

References vprASSERT.

   {
      vprASSERT(false && "Not supported right now.  If you want it, then implement it.");
      //return mGraph.isValid() && mSocketManager.hasActiveSockets();
      return false;
   }

void vpr::sim::Controller::setSimulationPauseTime

(

const vpr::Uint32

sleep_time

)

[inline]

Sets the amount of time (in microseconds) to sleep after processing a single event.

Definition at line 173 of file Controller.h.

   {
      mSleepTime = sleep_time;
   }

void vpr::sim::Controller::addMessageEvent	(	const vpr::Interval &	event_time,
		const NetworkGraph::net_edge_t	edge,
		const NetworkLine::LineDirection	dir
	)

Adds an event scheduled to occur at the given time to the queue of upcoming events.

Definition at line 94 of file Controller.cpp.

References vpr::Interval::getBaseVal(), mEvents, vprDBG_HVERB_LVL, vprDBG_SIM(), vprDEBUG, and vprDEBUG_FLUSH.

Referenced by vpr::sim::SocketManager::sendMessage().

{
   vprDEBUG(vprDBG_SIM, vprDBG_HVERB_LVL)
      << "Controller::addMessageEvent(): Adding message event scheduled for time "
      << event_time.getBaseVal() << " on edge " << edge << "\n"
      << vprDEBUG_FLUSH;
   mEvents.insert(std::pair<vpr::Interval, EventData>(event_time, EventData(edge, dir)));
}

void vpr::sim::Controller::addConnectionEvent	(	const vpr::Interval &	event_time,
		vpr::SocketImplSIM *	acceptor_sock
	)

Definition at line 105 of file Controller.cpp.

References vpr::sim::Controller::EventData::CONNECTION_INIT, vpr::Interval::getBaseVal(), mEvents, vprDBG_HVERB_LVL, vprDBG_SIM(), vprDEBUG, and vprDEBUG_FLUSH.

{
   vprDEBUG(vprDBG_SIM, vprDBG_HVERB_LVL)
      << "Controller::addConnectionEvent(): Adding connection request event scheduled for time "
      << event_time.getBaseVal() << "\n" << vprDEBUG_FLUSH;
   mEvents.insert(std::pair<vpr::Interval, EventData>(event_time, EventData(acceptor_sock, EventData::CONNECTION_INIT)));
}

void vpr::sim::Controller::addConnectionCompletionEvent	(	const vpr::Interval &	event_time,
		vpr::SocketImplSIM *	connector_sock
	)

Definition at line 114 of file Controller.cpp.

References vpr::sim::Controller::EventData::CONNECTION_COMPLETE, vpr::Interval::getBaseVal(), mEvents, vprDBG_HVERB_LVL, vprDBG_SIM(), vprDEBUG, and vprDEBUG_FLUSH.

Referenced by vpr::SocketStreamImplSIM::accept().

{
   vprDEBUG(vprDBG_SIM, vprDBG_HVERB_LVL)
      << "Controller::addConnectionCompletionEvent(): Adding connection "
      << "completion event scheduled for time " << event_time.getBaseVal()
      << "\n" << vprDEBUG_FLUSH;
   mEvents.insert(std::pair<vpr::Interval, EventData>(event_time, EventData(connector_sock, EventData::CONNECTION_COMPLETE)));
}

void vpr::sim::Controller::addLocalhostDeliveryEvent	(	const vpr::Interval &	event_time,
		vpr::SocketImplSIM *	connector_sock
	)

Definition at line 124 of file Controller.cpp.

References vpr::Interval::getBaseVal(), vpr::sim::Controller::EventData::LOCALHOST_DELIVERY, mEvents, vprDBG_HVERB_LVL, vprDBG_SIM(), vprDEBUG, and vprDEBUG_FLUSH.

Referenced by vpr::sim::SocketManager::sendMessage().

{
   vprDEBUG(vprDBG_SIM, vprDBG_HVERB_LVL)
      << "Controller::addConnectionCompletionEvent(): Adding localhost "
      << "delivery event scheduled for time " << event_time.getBaseVal()
      << "\n" << vprDEBUG_FLUSH;
   mEvents.insert(std::pair<vpr::Interval, EventData>(event_time, EventData(connector_sock, EventData::LOCALHOST_DELIVERY)));
}

void vpr::sim::Controller::flushPath	(	const vpr::SocketImplSIM *	sock,
		vpr::sim::NetworkGraph::VertexListPtr	path
	)

Flushes all messages (and associated events) on the given path destined for the given socket.

Definition at line 134 of file Controller.cpp.

References vpr::sim::NetworkLine::FORWARD, vpr::sim::NetworkGraph::getEdge(), vpr::sim::NetworkGraph::getLineProperty(), vpr::sim::NetworkGraph::isSource(), mEvents, mGraph, vpr::sim::NetworkLine::removeActiveMessages(), vpr::sim::NetworkLine::REVERSE, vprDBG_SIM(), vprDBG_STATE_LVL, vprDBG_VERB_LVL, vprDEBUG, and vprDEBUG_FLUSH.

{
vpr::DebugOutputGuard dbg_output(vprDBG_SIM, vprDBG_STATE_LVL,
                                 std::string("Controller::flushPath()\n"),
                                 std::string("End of Controller::flushPath()\n"));

   vpr::sim::NetworkGraph::VertexList::iterator source, dest;
   vpr::sim::NetworkGraph::net_edge_t current_line;
   bool got_next_line;

   source = dest = path->begin();
   ++dest;

   for ( ; dest != path->end(); ++dest )
   {
      boost::tie(current_line, got_next_line) = mGraph.getEdge(*source, *dest);

      if ( got_next_line )
      {
         vprDEBUG(vprDBG_SIM, vprDBG_STATE_LVL)
            << "Controller::flushPath(): Working on line " << current_line
            << std::endl << vprDEBUG_FLUSH;

         vpr::sim::NetworkLine& line_prop = mGraph.getLineProperty(current_line);
         vpr::sim::NetworkLine::LineDirection dir;
         std::vector<vpr::Interval> event_times;

         dir = mGraph.isSource(*source, current_line) ? NetworkLine::FORWARD
                                                      : NetworkLine::REVERSE;

         vprDEBUG(vprDBG_SIM, vprDBG_VERB_LVL)
            << "Controller::flushPath(): Removing active messages on line "
            << current_line << " in the "
            << ((dir == NetworkLine::FORWARD) ? "forward" : "reverse")
            << " queue\n" << vprDEBUG_FLUSH;

         line_prop.removeActiveMessages(sock, event_times, dir);

         // If the event_times vector has elements in it, these specify the
         // times at which flushed messages were scheduled to arrive.  We must
         // remove these events from the mEvents container.
         if ( ! event_times.empty() )
         {
            EventData test_event(current_line, dir);    // Message event
            event_map_t::iterator event_iter, end_iter;

            // For each of the scheduled event times, look up all the events
            // in the event container with that time and find the one that
            // matches the message flushed from the line above.
            for ( std::vector<vpr::Interval>::iterator i = event_times.begin();
                  i != event_times.end();
                  ++i )
            {
               vprDEBUG(vprDBG_SIM, vprDBG_STATE_LVL)
                  << "Controller::flushPath(): Looking for events scheduled to occur at "
                  << (*i).getBaseVal() << std::endl << vprDEBUG_FLUSH;

               boost::tie(event_iter, end_iter) = mEvents.equal_range(*i);

               // XXX: I'm not sure if std::remove_if() can be used here
               // because mEvents is currently an associative container.
               for ( ; event_iter != end_iter; ++event_iter )
               {
                  if ( test_event == (*event_iter).second )
                  {
                     vprDEBUG(vprDBG_SIM, vprDBG_VERB_LVL)
                        << "Controller::flushPath(): Removing event\n"
                        << vprDEBUG_FLUSH;
                     mEvents.erase(event_iter);
                  }
               }
            }
         }
      }

      // Finally, move the source to point to the current destination.  The
      // destination will be incremented as part of the for loop's
      // iteration.
      source = dest;
   }
}

void vpr::sim::Controller::processNextEvent

(

vpr::SocketImplSIM **

recvSocket = NULL

)

Processes the next event in the event queue no matter how far into the (simulated) future it occurs.

If there is an event in the queue, it will be processed by this method.

Parameters:

recvSocket

The socket that recv'ed the event (NULL if none)

Definition at line 217 of file Controller.cpp.

References vpr::sim::Controller::EventData::CONNECTION_COMPLETE, vpr::sim::Controller::EventData::CONNECTION_INIT, vpr::sim::NetworkLine::FORWARD, vpr::sim::NetworkLine::getArrivedMessage(), vpr::Interval::getBaseVal(), vpr::sim::Clock::getCurrentTime(), vpr::sim::NetworkGraph::getLineProperty(), vpr::sim::NetworkLine::getNetworkAddressString(), mClock, vpr::sim::Controller::EventData::MESSAGE, mEvents, mGraph, mSleepTime, vpr::sim::Clock::setCurrentTime(), vpr::ReturnStatus::success(), vpr::SystemPosix::usleep(), vprASSERT, vprDBG_HVERB_LVL, vprDBG_SIM(), vprDBG_STATE_LVL, vprDBG_VERB_LVL, vprDEBUG, and vprDEBUG_FLUSH.

Referenced by processEvents().

{
vpr::DebugOutputGuard dbg_output(vprDBG_SIM, vprDBG_STATE_LVL,
                                 std::string("Controller::processNextEvent()\n"),
                                 std::string("End of Controller::processNextEvent()\n"));

   if ( recvSocket != NULL )
   {
      (*recvSocket) = NULL;
   }

   event_map_t::iterator cur_event = mEvents.begin();

   if ( cur_event != mEvents.end() )
   {
      vpr::Interval event_time = (*cur_event).first;

      vprDEBUG(vprDBG_SIM, vprDBG_VERB_LVL)
         << "Controller::processNextEvent() [time = "
         << mClock.getCurrentTime().getBaseVal()
         << "]: Processing event scheduled to occur at time "
         << event_time.getBaseVal() << " (moving clock forward)\n"
         << vprDEBUG_FLUSH;

      mClock.setCurrentTime(event_time);

      if ( (*cur_event).second.type == EventData::MESSAGE )
      {
         NetworkGraph::net_edge_t event_edge = (*cur_event).second.edge;
         NetworkLine::LineDirection dir      = (*cur_event).second.direction;
         vpr::sim::NetworkLine& line         = mGraph.getLineProperty(event_edge);
         vpr::sim::MessagePtr msg;
         vpr::ReturnStatus status;

         // -------------------------------------------------------------------
         // Process event in the line's transmission queue.
         // -------------------------------------------------------------------

         status = line.getArrivedMessage(event_time, msg, dir);
         vprASSERT(status.success() && "No arrived message at this time");

         vprDEBUG(vprDBG_SIM, vprDBG_HVERB_LVL)
            << "Controller::processNextEvent(): Event is the arrival of a message for "
            << msg->getDestinationSocket()->getLocalAddr() << " on "
            << ((dir == vpr::sim::NetworkLine::FORWARD) ? "forward" : "reverse")
            << " queue of line " << line.getNetworkAddressString() << "\n"
            << vprDEBUG_FLUSH;

         moveMessage(msg, event_time, recvSocket);
      }
      else if ( (*cur_event).second.type == EventData::CONNECTION_COMPLETE )
      {
         vprDEBUG(vprDBG_SIM, vprDBG_HVERB_LVL)
            << "Controller::processNextEvent(): Event is a connection completion for "
            << (*cur_event).second.socket->getLocalAddr() << "\n"
            << vprDEBUG_FLUSH;

         if ( recvSocket != NULL )
         {
            *recvSocket = (*cur_event).second.socket;
         }
      }
      else if ( (*cur_event).second.type == EventData::CONNECTION_INIT )
      {
         vprDEBUG(vprDBG_SIM, vprDBG_HVERB_LVL)
            << "Controller::processNextEvent(): Event is a connection request to "
            << (*cur_event).second.socket->getLocalAddr() << "\n"
            << vprDEBUG_FLUSH;

         if ( recvSocket != NULL )
         {
            *recvSocket = (*cur_event).second.socket;
         }
      }
      else
      {
         vprDEBUG(vprDBG_SIM, vprDBG_HVERB_LVL)
            << "Controller::processNextEvent(): Event is a localhost message delivery to "
            << (*cur_event).second.socket->getLocalAddr() << "\n"
            << vprDEBUG_FLUSH;

         if ( recvSocket != NULL )
         {
            *recvSocket = (*cur_event).second.socket;
         }
      }

      mEvents.erase(cur_event);

      if ( mSleepTime != 0 )
      {
         vpr::System::usleep(mSleepTime);
      }
   }
}

void vpr::sim::Controller::processEvents

(

const vpr::Interval &

time_step

)

Limits the time frame for the occurrence of the next events to the given time step.

There may not be an event in the queue that occurs between the current time and the time step, and in that case, no event will be processed.

Parameters:

time_step

The maximum time step allowed for the simulation.

Definition at line 313 of file Controller.cpp.

References vpr::Interval::getBaseVal(), vpr::sim::Clock::getCurrentTime(), mClock, mEvents, processNextEvent(), vpr::sim::Clock::setCurrentTime(), vprDBG_SIM(), vprDBG_STATE_LVL, vprDBG_VERB_LVL, vprDEBUG, and vprDEBUG_FLUSH.

{
vpr::DebugOutputGuard dbg_output(vprDBG_SIM, vprDBG_STATE_LVL,
                                 std::string("Controller::processEvents()\n"),
                                 std::string("End of Controller::processEvents()\n"));

   vpr::SocketImplSIM* recv_sock;
   vpr::Interval event_time = mClock.getCurrentTime() + time_step;
   event_map_t::iterator next_event;

   vprDEBUG(vprDBG_SIM, vprDBG_VERB_LVL)
      << "Controller::processEvents [time = "
      << mClock.getCurrentTime().getBaseVal() << "]: Moving clock ahead "
      << time_step.getBaseVal() << " units to be " << event_time.getBaseVal()
      << std::endl << vprDEBUG_FLUSH;

   mClock.setCurrentTime(event_time);

   // The current time based on the time step is the same as or greater than
   // the time of the next event in the queue.  That means that that event is
   // eligible for processing.
   while ( (next_event = mEvents.begin()) != mEvents.end() &&
           (*next_event).first <= event_time )
   {
      processNextEvent(&recv_sock);
   }
}

vpr::Uint32 vpr::sim::Controller::getNumPendingEvents

(

)

[inline]

Return the number of events pending in the system.

Definition at line 223 of file Controller.h.

   {
      return mEvents.size();
   }

const vpr::sim::Clock& vpr::sim::Controller::getClock

(

)

const [inline]

Definition at line 228 of file Controller.h.

Referenced by vpr::SocketStreamImplSIM::accept(), and vpr::sim::SocketManager::sendMessage().

   {
      return mClock;
   }

vpr::sim::SocketManager& vpr::sim::Controller::getSocketManager

(

)

[inline]

Definition at line 233 of file Controller.h.

Referenced by vpr::SocketStreamImplSIM::accept().

   {
      return mSocketManager;
   }

vpr::sim::NetworkGraph& vpr::sim::Controller::getNetworkGraph

(

)

[inline]

Definition at line 238 of file Controller.h.

Referenced by vpr::sim::SocketManager::assignToNode(), vpr::sim::SocketManager::connect(), vpr::sim::SocketManager::ensureNetworkNodeIsRegistered(), vpr::sim::SocketManager::findRoute(), vpr::sim::SocketManager::sendMessage(), and vpr::sim::SocketManager::sendMessageTo().

   {
      return mGraph;
   }

void vpr::sim::Controller::operator=

(

const Controller &

o

)

[inline, protected]

Definition at line 278 of file Controller.h.

{;}

---

Member Data Documentation

vpr::sim::Clock vpr::sim::Controller::mClock [protected]

The global clock that we are using.

Definition at line 280 of file Controller.h.

Referenced by processEvents(), and processNextEvent().

vpr::sim::SocketManager vpr::sim::Controller::mSocketManager [protected]

The socket manager that we are using.

Definition at line 281 of file Controller.h.

Referenced by constructNetwork().

vpr::sim::NetworkGraph vpr::sim::Controller::mGraph [protected]

The network graph used for the simulation.

Definition at line 282 of file Controller.h.

Referenced by constructNetwork(), flushPath(), and processNextEvent().

event_map_t vpr::sim::Controller::mEvents [protected]

Definition at line 332 of file Controller.h.

Referenced by addConnectionCompletionEvent(), addConnectionEvent(), addLocalhostDeliveryEvent(), addMessageEvent(), flushPath(), processEvents(), and processNextEvent().

vpr::Uint32 vpr::sim::Controller::mSleepTime [protected]

Definition at line 334 of file Controller.h.

Referenced by processNextEvent().

---

The documentation for this class was generated from the following files:

• Controller.h
• Controller.cpp

---