---

/home/pauldt/projects/IDEA/IDEA-ALL/IDEA-DEV/Core/Utilities/Includes/ThreadTools.hh

Go to the documentation of this file.

// -*- Mode: c++ -*-
//     File: $Source: /home/cvs/ISG-Repository/IDEA-DEV/Core/Utilities/Includes/ThreadTools.hh,v $
//      Tag: $Name: DR_01_11_06 $
//      CVS: $Id: ThreadTools.hh,v 1.10 2005/12/30 22:06:06 rijsman Exp $
//     Info: $CVSROOT/IDEA-DEV/COPYRIGHT

#ifndef THREAD_TOOLS_HH
#define THREAD_TOOLS_HH

#include <ace/OS.h>
#include <ace/Synch.h>
#include <ace/Process_Mutex.h>
#include <ace/Process_Semaphore.h>
#include <ace/Thread_Manager.h>
#include <ace/Singleton.h>
#include <ace/Task.h>


#include <string>
#include <iostream>
#include <map>

#include "Singleton.hh"

#ifdef TRACE_LOCKS
 #include "LockTrace.hh"
#endif

namespace IDEA
{
  class ThreadNames:
    public Singleton<ThreadNames>
  {
    friend class Singleton<ThreadNames>;
  public:
    ~ThreadNames();
    static void registerThread( const std::string & name);
    static const std::string getName();
  private:
    ThreadNames();
    typedef std::map< ACE_thread_t, std::string > Thread2String;

    static Thread2String m_RegisteredThreads;
  };

  template<class LOCK> 
  void acquire( LOCK& lock, const std::string& locator )
  {
#ifdef TRACE_LOCKS
   LockTrace::instance()->lockInvoked( locator, (long) &lock );
#endif
    if( -1 == lock.acquire() )
        {
          std::cerr << "Error: acquiring a lock failed at location '" << locator << "'" << std::endl;
          ACE_OS::abort();
        }
#ifdef TRACE_LOCKS
   LockTrace::instance()->lockAcquired( locator, (long)  &lock );
#endif
  }

  template<class LOCK>
  void release( LOCK& lock, const std::string& locator)
  {
#ifdef TRACE_LOCKS
 LockTrace::instance()->unLockInvoked( locator, (long)  &lock );
#endif
    if( -1 == lock.release() )
      {
        std::cerr << "Error: releasing a lock failed at location '" << locator << "'" << std::endl;
        ACE_OS::abort();
      }
#ifdef TRACE_LOCKS
  LockTrace::instance()->unLockReleased( locator,  (long) &lock );
#endif
  }


 template<class LOCK> 
  class Guard
  {
  public:
    Guard( LOCK& lock, const std::string& locator = "unknown"):
      m_Lock( lock )
    {
      acquire<LOCK>( m_Lock, locator );
    }
    ~Guard()
    {
      release<LOCK>( m_Lock,"guard");
    }
  private:
    Guard(); 
    Guard( const Guard&); 
    Guard& operator=(const Guard& ); 

    LOCK& m_Lock;
  };
  
  typedef ACE_Thread_Mutex ThreadMutex;
  typedef ACE_Recursive_Thread_Mutex RecursiveThreadMutex;
  typedef ACE_Process_Mutex ProcessMutex;
  typedef ACE_Thread_Semaphore ThreadSemaphore;
  typedef ACE_Process_Semaphore ProcessSemaphore;

  /*
    }@
  */
}

#endif // ifndef THREAD_TOOLS_HH

---

Contact information © IDEA