itkMultiThreader.h

Go to the documentation of this file.

/*=========================================================================

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkMultiThreader.h,v $
  Language:  C++
  Date:      $Date: 2009-02-06 20:53:10 $
  Version:   $Revision: 1.30 $

  Copyright (c) Insight Software Consortium. All rights reserved.
  See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.

  Portions of this code are covered under the VTK copyright.
  See VTKCopyright.txt or http://www.kitware.com/VTKCopyright.htm for details.

     This software is distributed WITHOUT ANY WARRANTY; without even 
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
     PURPOSE.  See the above copyright notices for more information.

=========================================================================*/
#ifndef __itkMultiThreader_h
#define __itkMultiThreader_h

#include "itkObject.h"
#include "itkMutexLock.h"

#ifdef ITK_USE_SPROC
#include <sys/types.h>
#include <sys/resource.h>
#include <sys/types.h>
#include <sys/prctl.h>
#include <wait.h>
#include <errno.h>
#include <ulocks.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
#include <signal.h>
#include <sys/signal.h>
#include <sys/sysmp.h>
#include <sys/errno.h>
#include <sys/syssgi.h>

extern "C" {
#include <sys/pmo.h>
#include <fetchop.h>
}
#endif

#ifdef ITK_USE_PTHREADS
#include <pthread.h>
#endif

namespace itk
{
// The maximum number of threads allowed
#ifdef ITK_USE_SPROC
#define ITK_MAX_THREADS              128
#endif

#ifdef ITK_USE_PTHREADS
#define ITK_MAX_THREADS              128
#endif

#ifdef ITK_USE_WIN32_THREADS
#define ITK_MAX_THREADS              128
#endif

// cygwin threads are unreliable
#ifdef __CYGWIN__
#undef ITK_MAX_THREADS
#define ITK_MAX_THREADS 128 
#endif

// mingw threads cause crashes  so limit to 1
#if defined(__MINGW32__)
#undef ITK_MAX_THREADS
#define ITK_MAX_THREADS 1 
#endif
  
// On some sgi machines, threads and stl don't mix so limit to 1
#if defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730
#undef ITK_MAX_THREADS
#define ITK_MAX_THREADS 1 
#endif
  
#ifndef ITK_MAX_THREADS
#define ITK_MAX_THREADS 1
#endif

#ifdef ITK_USE_SPROC
typedef int ThreadProcessIDType;
#endif

#ifdef ITK_USE_PTHREADS
typedef void *(*ThreadFunctionType)(void *);
typedef pthread_t ThreadProcessIDType;
#define ITK_THREAD_RETURN_VALUE  NULL
#define ITK_THREAD_RETURN_TYPE   void *
#endif

#ifdef ITK_USE_WIN32_THREADS
typedef LPTHREAD_START_ROUTINE ThreadFunctionType;
typedef HANDLE                 ThreadProcessIDType;
#define ITK_THREAD_RETURN_VALUE 0
#define ITK_THREAD_RETURN_TYPE DWORD __stdcall
#endif

#ifndef ITK_THREAD_RETURN_VALUE
typedef void (*ThreadFunctionType)(void *);
typedef int ThreadProcessIDType;
#define ITK_THREAD_RETURN_VALUE
#define ITK_THREAD_RETURN_TYPE void
#endif
  
class ITKCommon_EXPORT MultiThreader : public Object 
{
public:
  typedef MultiThreader             Self;
  typedef Object                    Superclass;
  typedef SmartPointer<Self>        Pointer;
  typedef SmartPointer<const Self>  ConstPointer;

  itkNewMacro(Self);  

  itkTypeMacro(MultiThreader, Object);

  void SetNumberOfThreads( int numberOfThreads );
  itkGetMacro( NumberOfThreads, int );

  static void SetGlobalMaximumNumberOfThreads(int val);
  static int  GetGlobalMaximumNumberOfThreads();

  static void SetGlobalDefaultNumberOfThreads(int val);
  static int  GetGlobalDefaultNumberOfThreads();

  void SingleMethodExecute();

  void MultipleMethodExecute();

  void SetSingleMethod(ThreadFunctionType, void *data );

  void SetMultipleMethod( int index, ThreadFunctionType, void *data ); 

  // FIXME: Doesn't seem to be called anywhere...
  int SpawnThread( ThreadFunctionType, void *data );

  void TerminateThread( int thread_id );

#ifdef ITK_USE_SPROC
  static bool GetInitialized()
  { return m_Initialized; }
  static usptr_t * GetThreadArena()
  { return m_ThreadArena; }

  static void Initialize();
#endif
  
#ifdef ThreadInfoStruct
#undef ThreadInfoStruct
#endif
  struct ThreadInfoStruct
    {
#ifdef ITK_USE_SPROC
    char Pad1[128];
#endif
    int                 ThreadID;
    int                 NumberOfThreads;
    int                 *ActiveFlag;
    MutexLock::Pointer  ActiveFlagLock;
    void                *UserData;
    ThreadFunctionType  ThreadFunction;
    enum {SUCCESS, ITK_EXCEPTION, ITK_PROCESS_ABORTED_EXCEPTION, STD_EXCEPTION, UNKNOWN} ThreadExitCode;
#ifdef ITK_USE_SPROC
    char Pad2[128];
#endif
    };

protected:
  MultiThreader();
  ~MultiThreader();
  void PrintSelf(std::ostream& os, Indent indent) const;

private:
  
#ifdef ITK_USE_SPROC
  static bool m_Initialized;
  static usptr_t * m_ThreadArena;
  static int m_DevzeroFd;
#endif

  MultiThreader(const Self&); //purposely not implemented
  void operator=(const Self&); //purposely not implemented

  ThreadInfoStruct           m_ThreadInfoArray[ITK_MAX_THREADS];

  ThreadFunctionType         m_SingleMethod;
  ThreadFunctionType         m_MultipleMethod[ITK_MAX_THREADS];

  int                        m_SpawnedThreadActiveFlag    [ITK_MAX_THREADS];
  MutexLock::Pointer         m_SpawnedThreadActiveFlagLock[ITK_MAX_THREADS];
  ThreadProcessIDType        m_SpawnedThreadProcessID     [ITK_MAX_THREADS];
  ThreadInfoStruct           m_SpawnedThreadInfoArray     [ITK_MAX_THREADS];

  void                       *m_SingleData;
  void                       *m_MultipleData[ITK_MAX_THREADS];

  static int                  m_GlobalMaximumNumberOfThreads;

  /*  Global variable defining the default number of threads to set at
   *  construction time of a MultiThreader instance.  The
   *  m_GlobalDefaultNumberOfThreads must always be less than or equal to the
   *  m_GlobalMaximumNumberOfThreads and larger or equal to 1 once it has been
   *  initialized in the constructor of the first MultiThreader instantiation.
   */
  static int                  m_GlobalDefaultNumberOfThreads;

  int                        m_NumberOfThreads;

  
  static ITK_THREAD_RETURN_TYPE SingleMethodProxy( void *arg );

  ThreadProcessIDType DispatchSingleMethodThread(ThreadInfoStruct *);

  void WaitForSingleMethodThread(ThreadProcessIDType);

  
  friend class ProcessObject;
}; 

}  // end namespace itk
#endif