itkMultiThreader.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkMultiThreader.h,v $
  Language:  C++
  Date:      $Date: 2002/10/16 12:06:46 $
  Version:   $Revision: 1.19 $

  Copyright (c) 2002 Insight 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>
#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              32
#endif

#ifdef ITK_USE_PTHREADS
#define ITK_MAX_THREADS              32
#endif

#ifdef ITK_USE_WIN32_THREADS
#define ITK_MAX_THREADS              32
#endif

// cygwin threads are unreliable
#ifdef __CYGWIN__
#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 ITK_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);

  itkSetClampMacro( NumberOfThreads, int, 1, ITK_MAX_THREADS );
  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 ); 

  int SpawnThread( ThreadFunctionType, void *data );

  void TerminateThread( int thread_id );

  struct ThreadInfoStruct
  {
    int                 ThreadID;
    int                 NumberOfThreads;
    int                 *ActiveFlag;
    MutexLock::Pointer  ActiveFlagLock;
    void                *UserData;
  };

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

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

  int                        m_NumberOfThreads;

  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;
  static int                  m_GlobalDefaultNumberOfThreads;

  friend class ProcessObject;
};

}  // end namespace itk
#endif

---