itkMultiThreader.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright Insight Software Consortium
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0.txt
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 *=========================================================================*/
/*=========================================================================
 *
 *  Portions of this file are subject to the VTK Toolkit Version 3 copyright.
 *
 *  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
 *
 *  For complete copyright, license and disclaimer of warranty information
 *  please refer to the NOTICE file at the top of the ITK source tree.
 *
 *=========================================================================*/
#ifndef itkMultiThreader_h
#define itkMultiThreader_h

#include "itkMutexLock.h"
#include "itkThreadSupport.h"
#include "itkIntTypes.h"

#include "itkThreadPool.h"

namespace itk
{
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(ThreadIdType numberOfThreads);

  itkGetConstMacro(NumberOfThreads, ThreadIdType);

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

  static void SetGlobalDefaultUseThreadPool( const bool GlobalDefaultUseThreadPool );
  static bool GetGlobalDefaultUseThreadPool( );

  static void SetGlobalDefaultNumberOfThreads(ThreadIdType val);

  static ThreadIdType  GetGlobalDefaultNumberOfThreads();

  void SingleMethodExecute();

  void MultipleMethodExecute();

  void SetSingleMethod(ThreadFunctionType, void *data);

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

  ThreadIdType SpawnThread(ThreadFunctionType, void *data);

  void TerminateThread(ThreadIdType thread_id);

  itkSetObjectMacro(ThreadPool, ThreadPool);

  itkGetModifiableObjectMacro(ThreadPool, ThreadPool);

  itkSetMacro(UseThreadPool,bool);

  itkGetMacro(UseThreadPool,bool);

#ifdef ThreadInfoStruct
#undef ThreadInfoStruct
#endif
  struct ThreadInfoStruct
    {
    ThreadIdType ThreadID;
    ThreadIdType NumberOfThreads;
    int *ActiveFlag;
    MutexLock::Pointer ActiveFlagLock;
    void *UserData;
    ThreadFunctionType ThreadFunction;
    enum { SUCCESS, ITK_EXCEPTION, ITK_PROCESS_ABORTED_EXCEPTION, STD_EXCEPTION, UNKNOWN } ThreadExitCode;
    };

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

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

  // Thread pool instance and factory
  ThreadPool::Pointer m_ThreadPool;

  // choose whether to use Spawn or ThreadPool methods
  bool m_UseThreadPool;

  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 ThreadIdType m_GlobalMaximumNumberOfThreads;

  static bool m_GlobalDefaultUseThreadPool;

  /*  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 ThreadIdType m_GlobalDefaultNumberOfThreads;

  static ThreadIdType  GetGlobalDefaultNumberOfThreadsByPlatform();

  ThreadIdType m_NumberOfThreads;

  static ITK_THREAD_RETURN_TYPE SingleMethodProxy(void *arg);

  ThreadProcessIdType ThreadPoolDispatchSingleMethodThread(ThreadInfoStruct *);

  void ThreadPoolWaitForSingleMethodThread(ThreadProcessIdType);

  ThreadProcessIdType SpawnDispatchSingleMethodThread(ThreadInfoStruct *);

  void SpawnWaitForSingleMethodThread(ThreadProcessIdType);

  ThreadProcessIdType DispatchSingleMethodThread(ThreadInfoStruct *);

  void WaitForSingleMethodThread(ThreadProcessIdType);