---

Controller.h

Go to the documentation of this file.

/****************** <VPR heading BEGIN do not edit this line> *****************
 *
 * VR Juggler Portable Runtime
 *
 * Original Authors:
 *   Allen Bierbaum, Patrick Hartling, Kevin Meinert, Carolina Cruz-Neira
 *
 * -----------------------------------------------------------------
 * File:          $RCSfile: Controller.h,v $
 * Date modified: $Date: 2003/02/21 23:00:51 $
 * Version:       $Revision: 1.22 $
 * -----------------------------------------------------------------
 *
 ****************** <VPR heading END do not edit this line> ******************/

/*************** <auto-copyright.pl BEGIN do not edit this line> **************
 *
 * VR Juggler is (C) Copyright 1998-2003 by Iowa State University
 *
 * Original Authors:
 *   Allen Bierbaum, Christopher Just,
 *   Patrick Hartling, Kevin Meinert,
 *   Carolina Cruz-Neira, Albert Baker
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 *
 *************** <auto-copyright.pl END do not edit this line> ***************/

#ifndef _VPR_SIM_CONTROLLER_H_
#define _VPR_SIM_CONTROLLER_H_

#include <vpr/vprConfig.h>

#include <queue>
#include <utility>
#include <map>
#include <vpr/vprTypes.h>
#include <vpr/Sync/Mutex.h>
#include <vpr/Sync/Guard.h>
#include <vpr/Thread/Thread.h>
#include <vpr/Thread/TSObjectProxy.h>

#include <vpr/md/SIM/Clock.h>
#include <vpr/md/SIM/SocketManager.h>
#include <vpr/md/SIM/Network/NetworkGraph.h>


namespace vpr
{

class Interval;

namespace sim
{

class VPR_CLASS_API Controller
{
public:
   Controller();

   ~Controller()
   {
      /* Do nothing. */ ;
   }

   static void setInstance (Controller* c)
   {
      mInstance->setObject(c);
   }

   static Controller* instance()
   {
      // 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 constructNetwork(const std::string& graph_file);

   void destroyNetworkGraph()
   {
      mGraph.clear();
   }

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

   void setSimulationPauseTime(const vpr::Uint32 sleep_time)
   {
      mSleepTime = sleep_time;
   }

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

   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);

   void processNextEvent(vpr::SocketImplSIM** recvSocket = NULL);

   void processEvents(const vpr::Interval& time_step);

   vpr::Uint32 getNumPendingEvents()
   {
      return mEvents.size();
   }

   const vpr::sim::Clock& getClock() const
   {
      return mClock;
   }

   vpr::sim::SocketManager& getSocketManager()
   {
      return mSocketManager;
   }

   vpr::sim::NetworkGraph& getNetworkGraph()
   {
      return mGraph;
   }

private:
   void moveMessage(vpr::sim::MessagePtr, const vpr::Interval& cur_time,
                    vpr::SocketImplSIM** recvSocket);

   class ControllerTS
   {
   public:
      ControllerTS() : mObj(NULL)
      {
         /* Do nothing. */ ;
      }

      Controller* getObject() const
      {
         return mObj;
      }

      void setObject(Controller* c)
      {
         mObj = c;
      }

   private:
      Controller* mObj;
   };

   static Controller* mPrimordialInstance;
   static vpr::TSObjectProxy<ControllerTS> mInstance;

protected:  // --- Data members --- //
   // These two have to be here because Visual C++ will try to make them
   // exported public symbols.  This causes problems because copying vpr::Mutex
   // objects is not allowed.  We do not want to copy sim Controller instances
   // anyway, so this should be fine.
   Controller(const Controller& o) {;}
   void operator=(const Controller& o) {;}

   vpr::sim::Clock         mClock;              
   vpr::sim::SocketManager mSocketManager;      
   vpr::sim::NetworkGraph  mGraph;              
   struct EventData
   {
      enum EventType
      {
         MESSAGE,             
         CONNECTION_INIT,     
         CONNECTION_COMPLETE, 
         LOCALHOST_DELIVERY   
      };

      EventData(const NetworkGraph::net_edge_t _edge,
                const NetworkLine::LineDirection _dir)
         : type(MESSAGE), edge(_edge), direction(_dir)
      {
         ;
      }

      EventData(vpr::SocketImplSIM* sock, const EventType _type)
         : type(_type), socket(sock)
      {
         ;
      }

      bool operator==(const EventData& obj) const
      {
         bool status = false;

         if ( type == obj.type )
         {
            // This may need to be expanded to a full if/else if/else block
            // if the possible message data types expands beyond the above
            // four.
            status = (type == MESSAGE) ? (edge == obj.edge && direction == obj.direction)
                                       : (socket == obj.socket);
         }

         return status;
      }

      EventType                  type;
      NetworkGraph::net_edge_t   edge;
      NetworkLine::LineDirection direction;
      vpr::SocketImplSIM*        socket;
   };

   // This map of intervals to events is always sorted so that we can
   // iterate over it in increasing order of event times.
   typedef std::multimap<vpr::Interval, EventData> event_map_t;
   event_map_t mEvents;

   vpr::Uint32 mSleepTime;
};

} // End of sim namespace

} // End of vpr namespace


#endif

---