cmtkThreadParameterArray.h

Go to the documentation of this file.

/*
//
//  Copyright 1997-2009 Torsten Rohlfing
//
//  Copyright 2004-2010 SRI International
//
//  This file is part of the Computational Morphometry Toolkit.
//
//  http://www.nitrc.org/projects/cmtk/
//
//  The Computational Morphometry Toolkit is free software: you can
//  redistribute it and/or modify it under the terms of the GNU General Public
//  License as published by the Free Software Foundation, either version 3 of
//  the License, or (at your option) any later version.
//
//  The Computational Morphometry Toolkit 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 General Public License for more details.
//
//  You should have received a copy of the GNU General Public License along
//  with the Computational Morphometry Toolkit.  If not, see
//  <http://www.gnu.org/licenses/>.
//
//  $Revision: 2464 $
//
//  $LastChangedDate: 2010-10-19 09:54:33 -0700 (Tue, 19 Oct 2010) $
//
//  $LastChangedBy: torsten_at_home $
//
*/

#ifndef __cmtkThreadParameterArray_h_included_
#define __cmtkThreadParameterArray_h_included_

#include <cmtkconfig.h>

#include <System/cmtkThreads.h>
#include <System/cmtkThreadParameters.h>

namespace
cmtk
{


template<class TClass,class TParam = ThreadParameters<TClass> >
class ThreadParameterArray
{
public:
  ThreadParameterArray
  ( TClass *const thisObject, const size_t numberOfThreads )
  {
    this->m_AsynchronousThreadsRunning = false;
    this->m_NumberOfThreads = numberOfThreads;
    this->m_Ptr = Memory::AllocateArray<TParam>( numberOfThreads );
    for ( size_t i = 0; i < numberOfThreads; ++i )
      {
      this->m_Ptr[i].thisObject = thisObject;
      this->m_Ptr[i].ThisThreadIndex = i;
      this->m_Ptr[i].NumberOfThreads = numberOfThreads;
      this->m_Ptr[i].m_ThreadID = 0;
      }
  }

  ~ThreadParameterArray()
  {
    if ( this->m_AsynchronousThreadsRunning )
      this->CancelAsynchronousThreads();
    Memory::DeleteArray( this->m_Ptr );
  }

  const TParam& operator[]( const size_t i ) const { return this->m_Ptr[i]; }

  TParam& operator[]( const size_t i ) { return this->m_Ptr[i]; }

  TParam* GetPtr() { return this->m_Ptr; }

  const TParam* GetPtr() const { return this->m_Ptr; }

  size_t GetNumberOfThreads() const { return this->m_NumberOfThreads; }

  void RunInParallel( ThreadFunction threadCall )
  {
    Threads::RunThreads( threadCall, this->GetNumberOfThreads(), this->GetPtr(), sizeof( TParam ) );
  }

  void RunInParallelAsynchronous( ThreadFunction threadCall );

  void JoinAsynchronousThreads();

  void CancelAsynchronousThreads();

  bool IsRunning( const size_t idx )
  {
    return this->m_Ptr[idx].m_ThreadID;
  }

  void RunInParallelFIFO(ThreadFunction threadCall, const size_t numberOfThreadsTotal, const size_t firstThreadIdx = 0 );
    
private:
  size_t m_NumberOfThreads;
  
  TParam* m_Ptr;
 
  bool m_AsynchronousThreadsRunning;
};


} // namespace cmtk

#include "cmtkThreadParameterArray.txx"

#endif // #ifndef __cmtkThreadParameterArray_h_included_