cluster::ClusterManager Class Reference

Manages the synchronization of all ClusterPlugins. More...

#include <cluster/ClusterManager.h>

Collaboration diagram for cluster::ClusterManager:

[legend]List of all members.

Public Member Functions
void	addPlugin (ClusterPlugin *new_manager)
	Adds a new plugin to the ClusterManager.
void	removePlugin (ClusterPlugin *old_manager)
	Removes a plugin from the ClusterManager.
ClusterPlugin *	getPluginByGUID (const vpr::GUID &plugin_guid)
	Return the ClusterPlugin with the given GUID.
void	sendRequests ()
	Send each ClusterPlugin's requests.
void	preDraw ()
	Synchronize plugins directly before the kernel calls the draw() method.
void	postPostFrame ()
	Synchronize plugins directly after the kernel calls the postFrame() method.
void	createBarrier ()
	Cycle through ClusterPlugins until one of them can achieve swaplock.
void	recoverFromLostNode (gadget::Node *lost_node)
	Cause the cluster to recover when a connection to a ClusterNode is lost.
ClusterNetwork *	getNetwork ()
	Return the representation of the network which this cluster is running on.
bool	recognizeRemoteDeviceConfig (jccl::ConfigElementPtr element)
	Return true if ConfigElement is a remote device.
bool	recognizeClusterManagerConfig (jccl::ConfigElementPtr element)
	Return true if Configelement is a ClusterManager element.
bool	configAdd (jccl::ConfigElementPtr element)
	Adds the pending element to the configuration.
bool	configRemove (jccl::ConfigElementPtr element)
	Remove the pending element from the current configuration.
bool	configCanHandle (jccl::ConfigElementPtr element)
	Checks if this handler can process element.
jccl::ConfigElementPtr	getConfigElementPointer (const std::string &name)
	Get a pointer to the ConfigElement with the given name.
bool	isClusterActive ()
	Return true if we are running on a cluster.
bool	isClusterReady ()
	Return true if all dependancies have been satisfied.
bool	pluginsReady ()
	Return true if all plugins have their dependancies satisfied.
void	setClusterReady (const bool ready)
	Change the ready state of the ClusterManager.
vpr::Uint64	preDrawCallCount ()
	Return the number of times that preDraw() has been called.
vpr::Uint64	postPostFrameCallCount ()
	Return the number of times that postPostFrame() has been called.
Protected Member Functions
	ClusterManager ()
	Constructor is hidden, so no direct instantiation is allowed.
virtual	~ClusterManager ()
	ClusterManager (const ClusterManager &cm)
	Constructor is hidden, so no copying is allowed.
void	operator= (const ClusterManager &)
Friends
GADGET_API(std::ostream	getNodes ()&) operator<<(std std::vector< std::string >
	Get a list of hostnames for all ClusterNodes.

---

Detailed Description

Manages the synchronization of all ClusterPlugins.

Definition at line 63 of file ClusterManager.h.

---

Constructor & Destructor Documentation

cluster::ClusterManager::ClusterManager

(

)

[protected]

Constructor is hidden, so no direct instantiation is allowed.

Definition at line 157 of file ClusterManager.cpp.

      : mClusterActive( false )
      , mClusterReady( false )
      , mPreDrawCallCount(0)
      , mPostPostFrameCallCount(0)
   {
      mClusterNetwork = new ClusterNetwork();
      jccl::ConfigManager::instance()->addConfigElementHandler( mClusterNetwork );
      jccl::DependencyManager::instance()->registerChecker( new ClusterDepChecker() );
   }

cluster::ClusterManager::~ClusterManager

(

)

[protected, virtual]

Definition at line 168 of file ClusterManager.cpp.

   {;}

cluster::ClusterManager::ClusterManager

(

const ClusterManager &

cm

)

[inline, protected]

Constructor is hidden, so no copying is allowed.

Definition at line 73 of file ClusterManager.h.

      : jccl::ConfigElementHandler( cm )
   {
      /* Do nothing. */;
   }

---

Member Function Documentation

void cluster::ClusterManager::operator=

(

const ClusterManager &

)

[inline, protected]

Definition at line 79 of file ClusterManager.h.

   {
      /* Do nothing. */ ;
   }

void cluster::ClusterManager::addPlugin

(

ClusterPlugin *

new_manager

)

Adds a new plugin to the ClusterManager.

Definition at line 243 of file ClusterManager.cpp.

References gadget::AbstractNetworkManager::addHandler(), and gadgetDBG_RIM().

   {
      vpr::Guard<vpr::Mutex> guard( mPluginsLock );
      if ( !doesPluginExist(new_plugin) )
      {
         mPlugins.push_back( new_plugin );
         std::pair<vpr::GUID, ClusterPlugin*> p =
            std::make_pair( new_plugin->getHandlerGUID(), new_plugin );
         mPluginMap.insert( p );

         // We should do this here, but since we do not add the manager until
         // its configAdd currently you can see the problem
         jccl::ConfigManager::instance()->addConfigElementHandler( new_plugin );
         mClusterNetwork->addHandler( new_plugin );
         //We can still unregister it when removed below though
         vprDEBUG( gadgetDBG_RIM, vprDBG_CONFIG_LVL )
            << clrOutBOLD( clrCYAN, "[ClusterManager] " )
            << "Adding Plugin: " << new_plugin->getPluginName()
            << std::endl << vprDEBUG_FLUSH;
      }
   }

void cluster::ClusterManager::removePlugin

(

ClusterPlugin *

old_manager

)

Removes a plugin from the ClusterManager.

Definition at line 279 of file ClusterManager.cpp.

References gadgetDBG_RIM(), gadget::PacketHandler::getHandlerGUID(), and cluster::ClusterPlugin::getPluginName().

   {
      vpr::Guard<vpr::Mutex> guard( mPluginsLock );

      mPluginMap.erase( old_plugin->getHandlerGUID() );

      std::list<ClusterPlugin*>::iterator found
         = std::find(mPlugins.begin(), mPlugins.end(), old_plugin);

      if (mPlugins.end() != found)
      {
         vprDEBUG( gadgetDBG_RIM, vprDBG_CONFIG_LVL )
            << clrOutBOLD( clrCYAN, "[ClusterManager] " )
            << "Removing Plugin: " << old_plugin->getPluginName()
            << std::endl << vprDEBUG_FLUSH;
         mPlugins.erase(found);
         jccl::ConfigManager::instance()->removeConfigElementHandler(*found);
      }
   }

ClusterPlugin * cluster::ClusterManager::getPluginByGUID

(

const vpr::GUID &

plugin_guid

)

Return the ClusterPlugin with the given GUID.

Definition at line 265 of file ClusterManager.cpp.

   {
      std::map<vpr::GUID, ClusterPlugin*>::const_iterator i =
         mPluginMap.find( plugin_guid );
      if( i != mPluginMap.end() )
      {
         return ( (*i).second );
      }
      return NULL;
   }

void cluster::ClusterManager::sendRequests

(

)

Send each ClusterPlugin's requests.

Definition at line 313 of file ClusterManager.cpp.

References gadgetDBG_NET_MGR().

   {
      // Idea is to not create frame lock if we do not need to
      bool updateNeeded = false;
      vpr::Guard<vpr::Mutex> guard( mPluginsLock );

      vprDEBUG( gadgetDBG_NET_MGR, vprDBG_HVERB_LVL )
         << clrOutBOLD( clrCYAN,"[ClusterManager]" )
         << " sendRequests" << std::endl << vprDEBUG_FLUSH;

      for ( std::list<ClusterPlugin*>::iterator i = mPlugins.begin();
            i != mPlugins.end();
            ++i )
      {
         (*i)->sendRequests();
         updateNeeded = true;
      }

      // Only send end blocks if we really need to.
      if ( updateNeeded )
      {
         sendEndBlocksAndSignalUpdate(1);
      }
   }

void cluster::ClusterManager::preDraw

(

)

Synchronize plugins directly before the kernel calls the draw() method.

Definition at line 338 of file ClusterManager.cpp.

References gadgetDBG_NET_MGR().

   {
      // Idea is to not create frame lock if we do not need to
      bool updateNeeded = false;
      vpr::Guard<vpr::Mutex> guard( mPluginsLock );

      vprDEBUG( gadgetDBG_NET_MGR, vprDBG_HVERB_LVL )
         << clrOutBOLD( clrCYAN,"[ClusterManager]" )
         << " preDraw" << std::endl << vprDEBUG_FLUSH;

      for ( std::list<ClusterPlugin*>::iterator i = mPlugins.begin();
            i != mPlugins.end();
            ++i )
      {
         (*i)->preDraw();
         updateNeeded = true;
      }
      if ( updateNeeded )
      {
         mPreDrawCallCount++;
         sendEndBlocksAndSignalUpdate(2);
      }
   }

void cluster::ClusterManager::postPostFrame

(

)

Synchronize plugins directly after the kernel calls the postFrame() method.

Definition at line 362 of file ClusterManager.cpp.

References gadgetDBG_NET_MGR().

   {
      // -If not running
      //   -If all plugins ready
      //     - isClusterReady


      // Idea is to not create frame lock if we do not need to
      bool updateNeeded = false;
      vpr::Guard<vpr::Mutex> guard( mPluginsLock );

      vprDEBUG( gadgetDBG_NET_MGR, vprDBG_HVERB_LVL )
         << clrOutBOLD( clrCYAN,"[ClusterManager]" )
         << " postPostFrame" << std::endl << vprDEBUG_FLUSH;

      for ( std::list<ClusterPlugin*>::iterator i = mPlugins.begin();
            i != mPlugins.end();
            ++i )
      {
         (*i)->postPostFrame();
         updateNeeded = true;
      }
      if ( updateNeeded )
      {
         mPostPostFrameCallCount++;
         sendEndBlocksAndSignalUpdate(3);
      }
   }

void cluster::ClusterManager::createBarrier

(

)

Cycle through ClusterPlugins until one of them can achieve swaplock.

Definition at line 391 of file ClusterManager.cpp.

   {
      vpr::Guard<vpr::Mutex> guard( mPluginsLock );

      for ( std::list<ClusterPlugin*>::iterator i = mPlugins.begin();
            i != mPlugins.end();
            ++i )
      {
         //if ((*i)->isActive())
         //{  // As soon as we find a plug-in that creates
            // a barrier, we can continue. Maybe not since
            // this will not match up on different machines
            if ( (*i)->createBarrier() )
            {
               return;
            }
         //}
      }
   }

void cluster::ClusterManager::recoverFromLostNode

(

gadget::Node *

lost_node

)

Cause the cluster to recover when a connection to a ClusterNode is lost.

Definition at line 228 of file ClusterManager.cpp.

   {
      vpr::Guard<vpr::Mutex> guard( mPluginsLock );

      for ( std::list<ClusterPlugin*>::iterator i = mPlugins.begin();
            i != mPlugins.end();
            ++i )
      {
         (*i)->recoverFromLostNode( lost_node );
      }
   }

ClusterNetwork* cluster::ClusterManager::getNetwork

(

)

[inline]

Return the representation of the network which this cluster is running on.

Definition at line 149 of file ClusterManager.h.

   {
      return mClusterNetwork;
   }

bool cluster::ClusterManager::recognizeRemoteDeviceConfig

(

jccl::ConfigElementPtr

element

)

Return true if ConfigElement is a remote device.

Definition at line 465 of file ClusterManager.cpp.

References getConfigElementPointer(), and gadget::AbstractNetworkManager::isLocalHost().

   {
      std::string tp("input_parent");
      if ( element->getConfigDefinition()->isParent("input_device") &&
           element->getNum("device_host") > 0 )
      {
         std::string device_host =
            element->getProperty<std::string>( "device_host" );
         //std::cout << "Checking: " << element->getName() << std::endl;
         if ( !device_host.empty() )
         {
            // THIS IS A HACK: find a better way to do this
            jccl::ConfigElementPtr device_host_ptr =
               getConfigElementPointer( device_host );
            if ( device_host_ptr.get() != NULL )
            {
               std::string host_name =
                  device_host_ptr->getProperty<std::string>( "host_name" );
               if ( !cluster::ClusterNetwork::isLocalHost( host_name ) )
               {
                  return true;
               }// Device is on the local machine
            }// Could not find the deviceHost in the configuration
         }// Device is not a remote device since there is no name in the deviceHost field
      }// Else it is not a device, or does not have a deviceHost property
      return false;
   }

bool cluster::ClusterManager::recognizeClusterManagerConfig

(

jccl::ConfigElementPtr

element

)

Return true if Configelement is a ClusterManager element.

Definition at line 493 of file ClusterManager.cpp.

Referenced by configAdd(), configCanHandle(), and configRemove().

   {
     return( element->getID() == ClusterManager::getElementType() );
   }

bool cluster::ClusterManager::configAdd

(

jccl::ConfigElementPtr

element

)

Adds the pending element to the configuration.

Returns:

true iff element was successfully configured.

Definition at line 502 of file ClusterManager.cpp.

References configCanHandle(), gadgetDBG_INPUT_MGR(), gadgetDBG_RIM(), getConfigElementPointer(), gadget::AbstractNetworkManager::isLocalHost(), and recognizeClusterManagerConfig().

   {
      vpr::DebugOutputGuard dbg_output( gadgetDBG_RIM, vprDBG_STATE_LVL,
                              std::string( "Cluster Manager: Adding config element.\n" ),
                              std::string( "...done adding element.\n" ) );

      vprASSERT(configCanHandle(element));
      vprASSERT(recognizeClusterManagerConfig(element));

      bool ret_val = false;      // Flag to return success

     {
         vprDEBUG( gadgetDBG_RIM,vprDBG_CONFIG_STATUS_LVL)
            << clrOutBOLD(clrCYAN,"[ClusterManager] ")
            << "Configure the Cluster: " << element->getName()
            << std::endl << vprDEBUG_FLUSH;

         // Get a list of cluster nodes to use for this cluster.
         int num_nodes = element->getNum( std::string( "cluster_node" ) );

         vprDEBUG( gadgetDBG_RIM, vprDBG_CONFIG_STATUS_LVL )
            << clrOutBOLD( clrCYAN, "[ClusterManager] " )
            << "configAdd() Number of nodes: " << num_nodes
            << std::endl << vprDEBUG_FLUSH;

         for ( int i = 0 ; i < num_nodes ; ++i )
         {
            std::string new_node =
               element->getProperty<std::string>( "cluster_node" , i );
            vprDEBUG( gadgetDBG_RIM, vprDBG_CONFIG_STATUS_LVL )
               << clrOutBOLD( clrCYAN, "[ClusterManager] " )
               << "configAdd() New Node Name: " << new_node
               << std::endl << vprDEBUG_FLUSH;

            jccl::ConfigElementPtr new_node_element =
               getConfigElementPointer( new_node );
            std::string new_node_hostname =
               new_node_element->getProperty<std::string>( "host_name" );

            vprDEBUG( gadgetDBG_RIM, vprDBG_CONFIG_STATUS_LVL )
               << clrOutBOLD( clrCYAN, "[ClusterManager] " )
               << "configAdd() New Node Hostname: " << new_node_hostname
               << std::endl << vprDEBUG_FLUSH;

            if ( !cluster::ClusterNetwork::isLocalHost( new_node_hostname ) )
            {
               vprDEBUG( gadgetDBG_RIM, vprDBG_CONFIG_STATUS_LVL )
                  << clrOutBOLD( clrCYAN, "[ClusterManager] " )
                  << "configAdd() Added Node since it is non-local"
                  << std::endl << vprDEBUG_FLUSH;

               vpr::Guard<vpr::Mutex> guard( mNodesLock );
               mNodes.push_back( new_node_hostname );
            }
         }


         // Load the plugins.

         vpr::DebugOutputGuard dbg_output( gadgetDBG_RIM, vprDBG_STATE_LVL,
                                           std::string( "Handling cluster_manager element:\n" ),
                                           std::string( "-- end state -- \n" ) );

         // Keep this up to date with the version of the element definition we're
         // expecting to handle.
         const unsigned int cur_version(2);

         // If the element version is less than cur_version, we will not try to
         // proceed.  Instead, we'll print an error message and return false so
         // that the Config Manager knows this element wasn't consumed.
         if ( element->getVersion() < cur_version )
         {
            vprDEBUG( gadgetDBG_RIM, vprDBG_CRITICAL_LVL )
               << clrOutBOLD( clrRED, "ERROR" )
               << " [gadget::ClusterManager::configAdd()]: Element named '"
               << element->getName() << "'" << std::endl << vprDEBUG_FLUSH;
            vprDEBUG_NEXT( gadgetDBG_RIM, vprDBG_CRITICAL_LVL )
               << "is version " << element->getVersion()
               << ", but we require at least version " << cur_version
               << std::endl << vprDEBUG_FLUSH;
            vprDEBUG_NEXT( gadgetDBG_RIM, vprDBG_CRITICAL_LVL )
               << "Ignoring this element and moving on." << std::endl
               << vprDEBUG_FLUSH;

            ret_val = false;
         }
         // We got the right version of the config element and can proceed.
         else
         {
            const std::string plugin_path_prop_name( "plugin_path" );
            const int path_count( element->getNum( plugin_path_prop_name ) );
            std::vector<fs::path> search_path( path_count );

            for ( unsigned int i = 0; i < search_path.size(); ++i )
            {
               std::string temp_str =
                  vpr::replaceEnvVars( element->getProperty<std::string>( plugin_path_prop_name, i ) );

               try
               {
                  search_path[i] = fs::path( temp_str, fs::native );
               }
               catch( fs::filesystem_error& fsEx )
               {
                  vprDEBUG( vprDBG_ERROR, vprDBG_CRITICAL_LVL )
                     << clrOutNORM( clrRED, "ERROR:" )
                     << "[cluster::ClusterManager::configAdd()] File system "
                     << "exception caught while converting"
                     << std::endl << vprDEBUG_FLUSH;
                  vprDEBUG_NEXT( vprDBG_ERROR, vprDBG_CRITICAL_LVL )
                     << "'" << temp_str << "'"
                     << std::endl << vprDEBUG_FLUSH;
                  vprDEBUG_NEXT( vprDBG_ERROR, vprDBG_CRITICAL_LVL )
                     << "to a Boost.Filesystem path."
                     << std::endl << vprDEBUG_FLUSH;
                  vprDEBUG_NEXT( vprDBG_ERROR, vprDBG_CRITICAL_LVL )
                     << fsEx.what() << std::endl << vprDEBUG_FLUSH;
               }
            }

            // Append a default plug-in search path to search_path.
            const std::string gadget_base_dir( "GADGET_BASE_DIR" );
            const std::string vj_base_dir( "VJ_BASE_DIR" );
            std::string base_dir;

            // Try get to the value of $GADGET_BASE_DIR first.  If that fails,
            // fall back on $VJ_BASE_DIR.
            if ( !vpr::System::getenv( gadget_base_dir, base_dir ).success() )
            {
               if ( !vpr::System::getenv( vj_base_dir, base_dir ).success() )
               {
                  // If neither $GADGET_BASE_DIR nor $VJ_BASE_DIR is set, then
                  // we can append a default driver search path.
                  base_dir = VJ_ROOT_DIR;
               }
            }

#if defined(VPR_OS_IRIX) && defined(_ABIN32)
            const std::string bit_suffix("32");
#elif defined(VPR_OS_IRIX) && defined(_ABI64) || \
      defined(VPR_OS_Linux) && defined(__x86_64__)
            const std::string bit_suffix("64");
#else
            const std::string bit_suffix("");
#endif

            fs::path default_search_dir =
               fs::path(base_dir, fs::native) /
                  (std::string("lib") + bit_suffix) /
                  std::string("gadgeteer") / std::string("plugins");

            vprDEBUG( gadgetDBG_RIM, vprDBG_VERB_LVL )
               << "[cluster::ClusterManager::configAdd()] Appending "
               << "default search path '"
               << default_search_dir.native_directory_string() << "'\n"
               << vprDEBUG_FLUSH;

            search_path.push_back( default_search_dir );

            // --- Load cluster plugin dsos -- //
            // - Load individual plugins
            const std::string plugin_prop_name( "plugin" );
            const std::string get_version_func( "getGadgeteerVersion" );
            const std::string plugin_init_func( "initPlugin" );

            int plugin_count = element->getNum( plugin_prop_name );
            std::string plugin_dso_name;

            for ( int i = 0; i < plugin_count; ++i )
            {
               plugin_dso_name =
                  element->getProperty<std::string>(plugin_prop_name, i);

               if ( !plugin_dso_name.empty() )
               {
                  vprDEBUG( gadgetDBG_RIM, vprDBG_STATE_LVL )
                     << "[cluster::ClusterManager::configAdd()] Loading "
                     << "plugin DSO '" << plugin_dso_name << "'"
                     << std::endl << vprDEBUG_FLUSH;

                  vpr::LibraryPtr dso =
                     vpr::LibraryLoader::findDSO(plugin_dso_name, search_path);

                  if ( dso.get() != NULL )
                  {
                     vpr::ReturnStatus version_status;
                     VersionCheckCallable version_functor;
                     version_status =
                        vpr::LibraryLoader::callEntryPoint(dso,
                                                           get_version_func,
                                                           version_functor);

                     if ( ! version_status.success() )
                     {
                        vprDEBUG(gadgetDBG_RIM, vprDBG_CRITICAL_LVL)
                           << clrOutBOLD(clrRED, "ERROR")
                           << ": Version mismatch while loading cluster plug-in DSO '"
                           << plugin_dso_name << "'\n" << vprDEBUG_FLUSH;
                        vprDEBUG_NEXT(gadgetDBG_RIM, vprDBG_CRITICAL_LVL)
                           << "This plug-in will not be usable.\n"
                           << vprDEBUG_FLUSH;
                     }
                     else
                     {
                        vpr::ReturnStatus load_status;
                        PluginInitCallable init_functor(this);
                        load_status =
                           vpr::LibraryLoader::callEntryPoint(dso,
                                                              plugin_init_func,
                                                              init_functor);

                        if ( load_status.success() )
                        {
                           mLoadedPlugins.push_back(dso);
                        }
                     }
                  }
                  else
                  {
                     vprDEBUG(gadgetDBG_INPUT_MGR, vprDBG_CRITICAL_LVL)
                        << clrOutBOLD(clrRED, "ERROR")
                        << ": Failed to find cluster plug-in DSO '"
                        << plugin_dso_name << "'\n" << vprDEBUG_FLUSH;
                  }
               }
            }

            ret_val = true;
         }

         // Dump the status
         {
            vpr::DebugOutputGuard dbg_output( gadgetDBG_RIM, vprDBG_CONFIG_LVL,
                                    std::string( "New Cluster Manager state:\n" ),
                                    std::string( "-- end state -- \n" ) );
            vprDEBUG( gadgetDBG_RIM, vprDBG_CONFIG_LVL )
               << (*this) << std::endl << vprDEBUG_FLUSH;
         }
      }

      vpr::Guard<vpr::Mutex> guard( mClusterActiveLock );
      mClusterActive = true;

      return ret_val;         // Return the success flag if we added at all
    }

bool cluster::ClusterManager::configRemove

(

jccl::ConfigElementPtr

element

)

Remove the pending element from the current configuration.

Returns:

true iff the element (and any objects it represented) were successfully removed.

Definition at line 753 of file ClusterManager.cpp.

References gadgetDBG_RIM(), and recognizeClusterManagerConfig().

   {
      if ( recognizeClusterManagerConfig( element ) )
      {
         vprDEBUG( gadgetDBG_RIM,vprDBG_CONFIG_LVL )
            << "[ClusterManager] Shutdown the Cluster: " << element->getName()
            << std::endl << vprDEBUG_FLUSH;
         return( true );
      }
      else
      {
         vprDEBUG( gadgetDBG_RIM, vprDBG_CONFIG_LVL )
            << "[ClusterManager::configRemove()] ERROR: Something is "
            << "seriously wrong, we should never get here." << std::endl
            << vprDEBUG_FLUSH;
         return( false );
      }
   }

bool cluster::ClusterManager::configCanHandle

(

jccl::ConfigElementPtr

element

)

Checks if this handler can process element.

Returns:

true iff this handler can process element.

Definition at line 778 of file ClusterManager.cpp.

References recognizeClusterManagerConfig().

Referenced by configAdd().

   {
      return(recognizeClusterManagerConfig( element ));
   }

jccl::ConfigElementPtr cluster::ClusterManager::getConfigElementPointer

(

const std::string &

name

)

Get a pointer to the ConfigElement with the given name.

Definition at line 789 of file ClusterManager.cpp.

Referenced by configAdd(), and recognizeRemoteDeviceConfig().

   {
      jccl::ConfigManager* cfg_mgr = jccl::ConfigManager::instance();
      //cfg_mgr->lockPending();
      //cfg_mgr->unlockPending();
      for ( std::list<jccl::ConfigManager::PendingElement>::iterator i = cfg_mgr->getPendingBegin();
            i != cfg_mgr->getPendingEnd() ; ++i )
      {
         if ( (*i).mElement->getName() == name )
         {
            return( (*i).mElement );
         }
      }
      cfg_mgr->lockActive();
      jccl::ConfigElementPtr temp = cfg_mgr->getActiveConfig()->get( name );
      cfg_mgr->unlockActive();
      return( temp );
   }

bool cluster::ClusterManager::isClusterActive

(

)

[inline]

Return true if we are running on a cluster.

Definition at line 207 of file ClusterManager.h.

   {
      vpr::Guard<vpr::Mutex> guard( mClusterActiveLock );
      return mClusterActive;
   }

bool cluster::ClusterManager::isClusterReady

(

)

Return true if all dependancies have been satisfied.

Definition at line 171 of file ClusterManager.cpp.

References gadgetDBG_RIM(), and pluginsReady().

   {
      // -If the cluster is active and not ready
      //   -If a StartBarrier jccl::ConfigElement does not exist
      //    -Warn the user and set cluster ready
      //   -Get new value of mClusterReady from asking all plugins
      // -Return the new mClusterReady

      vpr::Guard<vpr::Mutex> ready_guard( mClusterReadyLock );
      vpr::Guard<vpr::Mutex> active_guard( mClusterActiveLock );

      if ( mClusterActive && !mClusterReady )
      {
         if ( !jccl::ConfigManager::instance()->hasElementType( "start_barrier_plugin" ) )
         {
            vprDEBUG(gadgetDBG_RIM, vprDBG_WARNING_LVL)
               << clrOutBOLD(clrCYAN, "NOTE:") << std::endl << vprDEBUG_FLUSH;
            vprDEBUG_NEXT(gadgetDBG_RIM, vprDBG_WARNING_LVL)
               << "The start_barrier_plugin config element does not exist.\n"
               << vprDEBUG_FLUSH;
            vprDEBUG_NEXT(gadgetDBG_RIM, vprDBG_WARNING_LVL)
               << "If your application depends on each node starting at the "
               << "same time,\n" << vprDEBUG_FLUSH;
            vprDEBUG_NEXT(gadgetDBG_RIM, vprDBG_WARNING_LVL)
               << "then you should load and configure the Start Barrier "
               << "Plug-in.\n" << vprDEBUG_FLUSH;

            mClusterReady = true;
         }
      }
      // Lock it here so that we can avoid confusion in pluginsReady()
      vpr::Guard<vpr::Mutex> guard( mPluginsLock );
      return( mClusterReady && pluginsReady() );
   }

bool cluster::ClusterManager::pluginsReady

(

)

Return true if all plugins have their dependancies satisfied.

Definition at line 206 of file ClusterManager.cpp.

Referenced by isClusterReady().

   {
      // Plugins are already locked since we only call this method from
      // isClusterReady which is only called by
      // StartBarrierPlugin::postPostFrame which has already locked the list
      // of plugins.

      //vpr::Guard<vpr::Mutex> guard(mPluginsLock);

      for ( std::list<ClusterPlugin*>::iterator i = mPlugins.begin();
            i != mPlugins.end();
            ++i )
      {
         if ( !(*i)->isPluginReady() )
         {
            return false;
         }
      }

      return true;
   }

void cluster::ClusterManager::setClusterReady

(

const bool

ready

)

[inline]

Change the ready state of the ClusterManager.

Definition at line 226 of file ClusterManager.h.

References gadgetDBG_RIM().

   {
      vpr::Guard<vpr::Mutex> guard( mClusterReadyLock );

      vprDEBUG( gadgetDBG_RIM, vprDBG_CONFIG_LVL )
         << clrOutBOLD( clrCYAN, "[ClusterManager]" )
         << " Cluster is ready." << std::endl << vprDEBUG_FLUSH;

      mClusterReady = ready;
   }

vpr::Uint64 cluster::ClusterManager::preDrawCallCount

(

)

[inline]

Return the number of times that preDraw() has been called.

Definition at line 255 of file ClusterManager.h.

   {
      return mPreDrawCallCount;
   }

vpr::Uint64 cluster::ClusterManager::postPostFrameCallCount

(

)

[inline]

Return the number of times that postPostFrame() has been called.

Definition at line 263 of file ClusterManager.h.

   {
      return mPostPostFrameCallCount;
   }

---

Friends And Related Function Documentation

GADGET_API ( std::ostream getNodes

(

)

[friend]

Get a list of hostnames for all ClusterNodes.

Definition at line 246 of file ClusterManager.h.

   {
      vpr::Guard<vpr::Mutex> guard( mNodesLock );
      return mNodes;
   }

---

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

• ClusterManager.h
• ClusterManager.cpp

---