vrj::PerformanceMediator Class Reference

Performance mediator used by the kernel to communicate with performance monitoring plug-ins. More...

#include <vrj/Performance/PerformanceMediator.h>

Collaboration diagram for vrj::PerformanceMediator:

[legend]List of all members.

Public Member Functions
	PerformanceMediator ()
virtual	~PerformanceMediator ()
void	setPerfPlugin (vrj::PerfPlugin *plugin)
Protected Member Functions
void	loadPerfPlugin ()
	Enables the remote performance monitoring interface object.
	PerformanceMediator (const PerformanceMediator &)
void	operator= (const PerformanceMediator &)

---

Detailed Description

Performance mediator used by the kernel to communicate with performance monitoring plug-ins.

Definition at line 57 of file PerformanceMediator.h.

---

Constructor & Destructor Documentation

vrj::PerformanceMediator::PerformanceMediator

(

)

Definition at line 57 of file PerformanceMediator.cpp.

References loadPerfPlugin().

   : mPerfIf(NULL)
   {
      loadPerfPlugin();
   }

vrj::PerformanceMediator::~PerformanceMediator

(

)

[virtual]

Definition at line 63 of file PerformanceMediator.cpp.

References vrj::PerfPlugin::disable(), and vrj::PerfPlugin::isEnabled().

   {
      if ( NULL != mPerfIf && mPerfIf->isEnabled() )
      {
         mPerfIf->disable();

         delete mPerfIf;
         mPerfIf = NULL;
      }
   }

vrj::PerformanceMediator::PerformanceMediator

(

const PerformanceMediator &

)

[inline, protected]

Definition at line 69 of file PerformanceMediator.h.

      {
         ;
      }

---

Member Function Documentation

void vrj::PerformanceMediator::setPerfPlugin

(

vrj::PerfPlugin *

plugin

)

Definition at line 198 of file PerformanceMediator.cpp.

References vrj::PerfPlugin::disable(), vrj::PerfPlugin::enable(), vrj::PerfPlugin::init(), and vrj::PerfPlugin::isEnabled().

   {
      // If we already have a remote performance monitoring plug-in, discard it
      // first.
      if ( NULL != mPerfIf )
      {
         vprDEBUG(jcclDBG_RECONFIG, vprDBG_STATE_LVL)
         << "[PerformanceMediator::setPerfPlugin()] "
            << "Removing old remote performance monitoring plug-in\n"
            << vprDEBUG_FLUSH;

         if ( mPerfIf->isEnabled() )
         {
            mPerfIf->disable();
         }

         delete mPerfIf;
      }

      vprDEBUG(jcclDBG_RECONFIG, vprDBG_VERB_LVL)
      << "[PerformanceMediator::setPerfPlugin()] "
         << "Enabling new remote performance monitoring plug-in\n"
         << vprDEBUG_FLUSH;
      mPerfIf = plugin;

      if ( NULL != mPerfIf )
      {
         // Attempt to initialize the remote performance monitoring component.
         if ( mPerfIf->init().success() )
         {
            // Now, attempt to enable remote performance monitoring hooks.
            if ( ! mPerfIf->enable().success() )
            {
               vprDEBUG(jcclDBG_RECONFIG, vprDBG_WARNING_LVL)
               << clrOutBOLD(clrYELLOW, "WARNING:")
               << " Failed to enable remote performance monitoring hooks.\n"
                  << vprDEBUG_FLUSH;
               delete mPerfIf;
               mPerfIf = NULL;
            }
         }
         // Initialization failed.
         else
         {
            vprDEBUG(jcclDBG_RECONFIG, vprDBG_WARNING_LVL)
            << clrOutBOLD(clrYELLOW, "WARNING:")
            << " Failed to initialize remote performance monitoring hooks.\n"
               << vprDEBUG_FLUSH;
            delete mPerfIf;
            mPerfIf = NULL;
         }
      }
   }

void vrj::PerformanceMediator::loadPerfPlugin

(

)

[protected]

Enables the remote performance monitoring interface object.

Definition at line 122 of file PerformanceMediator.cpp.

Referenced by PerformanceMediator().

   {
      vprASSERT(NULL == mPerfIf && "PerformanceMediator interface object already instantiated.");

      const std::string vj_base_dir("VJ_BASE_DIR");
      std::string base_dir;

      if ( ! vpr::System::getenv(vj_base_dir, base_dir).success() )
      {
         return;
      }

      const std::string no_perf_plugin("NO_PERF_PLUGIN");
      std::string junk;

      // If the user has the environment variable NO_PERF_PLUGIN set (to any
      // value), do not attempt to load the plug-in.
      if ( vpr::System::getenv(no_perf_plugin, junk).success() )
      {
         vprDEBUG(vprDBG_ALL, vprDBG_STATE_LVL)
            << "Remote performance visualization plug-in loading disabled "
            << "via NO_PERF_PLUGIN." << std::endl << vprDEBUG_FLUSH;
         return;
      }

#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

      std::vector<fs::path> search_path(1);
      search_path[0] = fs::path(base_dir, fs::native) /
                       (std::string("lib") + bit_suffix) /
                       std::string("vrjuggler") / std::string("plugins");

      // In the long run, we may not want to hard-code the base name of the
      // plug-in we load.  If we ever reach a point where we have multiple ways
      // of implementing remote performance monitoring, we could have options
      // for which plug-in to load.
      const std::string perf_mon_dso("corba_perf_mon");
      const std::string init_func("initPlugin");
      Callable functor(this);
      vpr::ReturnStatus status;
      status =
         vpr::LibraryLoader::findDSOAndCallEntryPoint(perf_mon_dso,
                                                      search_path, init_func,
                                                      functor, mPluginDSO);

      if ( ! status.success() )
      {
         vprDEBUG(vprDBG_ALL, vprDBG_WARNING_LVL)
            << "Failed to load the remote performance monitoring plug-in."
            << std::endl << vprDEBUG_FLUSH;
         vprDEBUG_NEXT(vprDBG_ALL, vprDBG_WARNING_LVL)
            << "Remote performance monitoring is disabled." << std::endl
            << vprDEBUG_FLUSH;
         vprDEBUG_NEXT(vprDBG_ALL, vprDBG_WARNING_LVL)
            << "(This is not a fatal error.)" << std::endl << vprDEBUG_FLUSH;

         // The plug-in is not usable, so we can unload it.
         if ( mPluginDSO.get() != NULL )
         {
            if ( mPluginDSO->isLoaded() )
            {
               mPluginDSO->unload();
            }

            mPluginDSO.reset();
         }
      }
   }

void vrj::PerformanceMediator::operator=

(

const PerformanceMediator &

)

[inline, protected]

Definition at line 73 of file PerformanceMediator.h.

      {
         ;
      }

---

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

• PerformanceMediator.h
• PerformanceMediator.cpp

---