ProfileManager.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$
 * Date modified: $Date: 2005-05-16 15:13:18 -0500 (Mon, 16 May 2005) $
 * Version:       $Revision: 17502 $
 * -----------------------------------------------------------------
 *
 ****************** <VPR heading END do not edit this line> ******************/

/*************** <auto-copyright.pl BEGIN do not edit this line> **************
 *
 * VR Juggler is (C) Copyright 1998-2005 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_PROFILE_MANAGER_H
#define VPR_PROFILE_MANAGER_H

#include <vpr/vprConfig.h>

#include <string>
#include <vector>
#include <map>
#include <sstream>

#include <vpr/Sync/Guard.h>
#include <vpr/Sync/Mutex.h>

#include <vpr/Perf/ProfileIterator.h>
#include <vpr/Perf/ProfileNode.h>

#include <vpr/Thread/TSObjectProxy.h>
#include <vpr/Thread/Thread.h>

namespace vpr
{

   class VPR_CLASS_API ProfileManager
   {
   public:
      struct ThreadProfileData
      {
         ThreadProfileData()
            : mRoot("root")
         {
            mCurrentNode = &mRoot;
         }

         ProfileNode    mRoot;         
         ProfileNode*   mCurrentNode;  
         vpr::Interval  mResetTime;    
      };

      typedef std::map<std::string, vpr::Interval> ProfileSampleResult;

      static void startProfile(const char* profileName,
                               const unsigned int queueSize = 0);

      static void stopProfile();

      static ProfileNode* getRootNode(vpr::Thread* thread = NULL);

      static void printTree(bool forAllThreads = true);

      static ProfileIterator begin()
      {
         return ProfileIterator(getRootNode());
      }

      static ProfileIterator end()
      {
         return ProfileIterator(NULL);
      }

      static void releaseIterator(ProfileIterator* iterator)
      {
         delete iterator;
      }

      static void reset();

      static float getTimeSinceReset();

   public:
      static std::vector<std::string> getNames()
      {
         std::vector<std::string> names_list;
         getNamesRecursively(names_list, getRootNode());
         return names_list;
      }

      static ProfileSampleResult getSampleResult()
      {
         ProfileSampleResult sample_time_map;
         std::vector<Thread*>::size_type num_threads =
            vpr::ThreadManager::instance()->getNumThreads();
         for ( std::vector<Thread*>::size_type t = 0; t < num_threads; ++t )
         {
            vpr::Thread* thread = vpr::ThreadManager::instance()->getThread(t);
            getSampleResultRecursively(sample_time_map, getRootNode(thread));
         }
         return sample_time_map;
      }

       static float getNamedNodeSample( const char * nodeName )
       {
           ProfileNode* node = getRootNode()->getNamedChild( nodeName );

           if(node == NULL )
           {
              return 0.0;
           }
           else
           {
              return node->getLastSample().msecf();
           }
       }

   private:
      static TSObjectProxy<ThreadProfileData>  mThreadData;    
      // Private Member Functions
      static void getNamesRecursively( std::vector<std::string>& nameList,
                                       ProfileNode* node )
      {
         if ( NULL == node )
         {
            return;
         }

         getNamesRecursively(nameList, node->getSibling());
         nameList.push_back(node->getName());
         getNamesRecursively(nameList, node->getChild());
       }

      static void getSampleResultRecursively( ProfileSampleResult& sampleTimeMap,
                                          ProfileNode* node )
      {
         if ( NULL == node )
         {
            return;
         }

         getSampleResultRecursively(sampleTimeMap, node->getSibling());
         vpr::Interval last_sample;
         last_sample.msecf( node->getNodeHistoryRange().first->msecf());
         std::string name = node->getName();
         sampleTimeMap[name] = last_sample;
         getSampleResultRecursively(sampleTimeMap, node->getChild());
      }
   };


namespace prof
{
#if defined(DISABLE_VPR_PROFILE)
   inline void start(const char* name) {;}
   inline void start(const char* name, unsigned int histSize) {;}
   inline void next(const char* name) {;}
   inline void next(const char* name, unsigned int histSize) {;}
   inline void stop() {;}
   inline void printTree() {;}
#else

   inline void start(const char* name)
   {
      vpr::ProfileManager::startProfile(name);
   }
   inline void start(const char* name, unsigned int histSize)
   {
      vpr::ProfileManager::startProfile(name,histSize);
   }
   inline void next(const char* name)
   {
      vpr::ProfileManager::stopProfile();
      vpr::ProfileManager::startProfile(name);
   }
   inline void next(const char* name, unsigned int histSize)
   {
      vpr::ProfileManager::stopProfile();
      vpr::ProfileManager::startProfile(name,histSize);
   }
   inline void stop()
   {
      vpr::ProfileManager::stopProfile();
   }
   inline void printTree()
   {
      vpr::ProfileManager::printTree();
   }
#endif
} // End prof namespace

   class ProfileSample
   {
   public:
      ProfileSample(const char * name)
      {
         ProfileManager::startProfile(name);
      }

      ProfileSample(const char * name, const unsigned int queue_size)
      {
         ProfileManager::startProfile(name, queue_size);
      }

      ~ProfileSample()
      {
         ProfileManager::stopProfile();
      }
   };


#if defined(DISABLE_VPR_PROFILE)
#define  VPR_PROFILE_GUARD( name )
#else
#define  VPR_PROFILE_GUARD( name )        vpr::ProfileSample __profile( name )
#endif

#if defined(DISABLE_VPR_PROFILE)
#define  VPR_PROFILE_GUARD_HISTORY( name, queue_size )
#else
#define  VPR_PROFILE_GUARD_HISTORY( name, queue_size )         vpr::ProfileSample __profile( name, queue_size)
#endif

#if defined(DISABLE_VPR_PROFILE)
#define  VPR_PROFILE_RESULTS( )
#else
#define  VPR_PROFILE_RESULTS( )        vpr::ProfileManager::printTree( )
#endif

} // end vpr namespace

#endif

---