ENH: rename NumberOfThreads into NumberOfWorkUnits in filters

Change-Id: I7148f0e00ed76f8fcf21b371f5c1c1c0effcb26d

Examples/Filtering/DiffusionTensor3DReconstructionImageFilter.cxx

@@ -281,7 +281,7 @@ int main( int argc, char *argv[] )
   tensorReconstructionFilter->SetGradientImage( DiffusionVectors, reader->GetOutput() );
 
   // This is necessary until we fix netlib/dsvdc.c
-  tensorReconstructionFilter->SetNumberOfThreads( 1 );
+  tensorReconstructionFilter->SetNumberOfWorkUnits( 1 );
 
   tensorReconstructionFilter->SetBValue(b0);
   tensorReconstructionFilter->SetThreshold( static_cast<

Modules/Core/Common/include/itkDomainThreader.h

@@ -50,7 +50,7 @@ namespace itk
  *  class, the method to partition the data is handled, the logic for
  *  determining the number of threads is determined, and operations surrounding
  *  the threading are encapsulated into the class with the
- *  \c DetermineNumberOfThreadsToUse, \c BeforeThreadedExecution, \c ThreadedExecution,
+ *  \c DetermineNumberOfWorkUnitsToUse, \c BeforeThreadedExecution, \c ThreadedExecution,
  *  and \c AfterThreadedExecution virtual methods.
  *
  *  \tparam TDomainPartitioner A class that inherits from
@@ -95,13 +95,13 @@ class ITK_TEMPLATE_EXPORT DomainThreader: public Object
 
   /** Accessor for number of threads that were actually used in the last
    * ThreadedExecution. */
-  itkGetConstMacro( NumberOfThreadsUsed, ThreadIdType );
+  itkGetConstMacro( NumberOfWorkUnitsUsed, ThreadIdType );
 
   /** Return the multithreader used by this class. */
   MultiThreaderBase * GetMultiThreader() const;
 
-  /** Convenience methods to set/get the maximum number of threads to use.
-   * \warning When setting the maximum number of threads, it will be clamped by
+  /** Convenience methods to set/get the maximum number of work units to use.
+   * \warning When setting the maximum number of work units, it will be clamped by
    * itk::MultiThreaderBase::GetGlobalMaximumNumberOfThreads() and ITK_MAX_THREADS.
    * */
   ThreadIdType GetMaximumNumberOfThreads() const;
@@ -113,7 +113,7 @@ class ITK_TEMPLATE_EXPORT DomainThreader: public Object
 
   /** This is evauated at the beginning of Execute() so that it can be used in
    * BeforeThreadedExecution(). */
-  virtual void DetermineNumberOfThreadsUsed();
+  virtual void DetermineNumberOfWorkUnitsUsed();
 
   /** When \c Execute is run, this method is run singled-threaded before \c
    * ThreadedExecution.  Inside this method optional operations such as
@@ -158,7 +158,7 @@ class ITK_TEMPLATE_EXPORT DomainThreader: public Object
    * the number allocated by the threader if the object does not split
    * well into that number.
    * This value is determined at the beginning of \c Execute(). */
-  ThreadIdType                             m_NumberOfThreadsUsed;
+  ThreadIdType                             m_NumberOfWorkUnitsUsed;
   typename DomainPartitionerType::Pointer  m_DomainPartitioner;
   DomainType                               m_CompleteDomain;
   MultiThreaderBase::Pointer               m_MultiThreader;

Modules/Core/Common/include/itkDomainThreader.hxx

@@ -27,10 +27,10 @@ template< typename TDomainPartitioner, typename TAssociate >
 DomainThreader< TDomainPartitioner, TAssociate >
 ::DomainThreader()
 {
-  this->m_DomainPartitioner   = DomainPartitionerType::New();
-  this->m_MultiThreader       = MultiThreaderBase::New();
-  this->m_NumberOfThreadsUsed = 0;
-  this->m_Associate           = nullptr;
+  this->m_DomainPartitioner = DomainPartitionerType::New();
+  this->m_MultiThreader = MultiThreaderBase::New();
+  this->m_NumberOfWorkUnitsUsed = 0;
+  this->m_Associate = nullptr;
 }
 
 template< typename TDomainPartitioner, typename TAssociate >
@@ -75,7 +75,7 @@ DomainThreader< TDomainPartitioner, TAssociate >
   this->m_Associate = enclosingClass;
   this->m_CompleteDomain = completeDomain;
 
-  this->DetermineNumberOfThreadsUsed();
+  this->DetermineNumberOfWorkUnitsUsed();
 
   this->BeforeThreadedExecution();
 
@@ -88,26 +88,26 @@ DomainThreader< TDomainPartitioner, TAssociate >
 template< typename TDomainPartitioner, typename TAssociate >
 void
 DomainThreader< TDomainPartitioner, TAssociate >
-::DetermineNumberOfThreadsUsed()
+::DetermineNumberOfWorkUnitsUsed()
 {
   const ThreadIdType threaderNumberOfThreads = this->GetMultiThreader()->GetNumberOfThreads();
 
   // Attempt a single dummy partition, just to get the number of subdomains actually created
   DomainType subdomain;
-  this->m_NumberOfThreadsUsed = this->m_DomainPartitioner->PartitionDomain(0,
+  this->m_NumberOfWorkUnitsUsed = this->m_DomainPartitioner->PartitionDomain(0,
                                             threaderNumberOfThreads,
                                             this->m_CompleteDomain,
                                             subdomain);
 
-  if( this->m_NumberOfThreadsUsed < threaderNumberOfThreads )
+  if( this->m_NumberOfWorkUnitsUsed < threaderNumberOfThreads )
     {
     // If PartitionDomain is only able to create a lesser number of subdomains,
     // ensure that superfluous threads aren't created
     // DomainThreader::SetMaximumNumberOfThreads *should* already have been called by this point,
     // but it's not fatal if it somehow gets called later
-    this->GetMultiThreader()->SetNumberOfThreads(this->m_NumberOfThreadsUsed);
+    this->GetMultiThreader()->SetNumberOfThreads(this->m_NumberOfWorkUnitsUsed);
     }
-  else if( this->m_NumberOfThreadsUsed > threaderNumberOfThreads )
+  else if( this->m_NumberOfWorkUnitsUsed > threaderNumberOfThreads )
     {
     itkExceptionMacro( "A subclass of ThreadedDomainPartitioner::PartitionDomain"
                       << "returned more subdomains than were requested" );

Modules/Core/Common/include/itkImageSource.hxx

@@ -210,7 +210,7 @@ ImageSource<TOutputImage>
 
   const OutputImageType *outputPtr = this->GetOutput();
   const ImageRegionSplitterBase * splitter = this->GetImageRegionSplitter();
-  const unsigned int validThreads = splitter->GetNumberOfSplits(outputPtr->GetRequestedRegion(), this->GetNumberOfThreads());
+  const unsigned int validThreads = splitter->GetNumberOfSplits(outputPtr->GetRequestedRegion(), this->GetNumberOfWorkUnits());
 
   this->GetMultiThreader()->SetNumberOfThreads(validThreads);
   this->GetMultiThreader()->SetSingleMethod(callbackFunction, &str);
@@ -238,7 +238,7 @@ ImageSource< TOutputImage >
     }
   else
     {
-    this->GetMultiThreader()->SetNumberOfThreads(this->GetNumberOfThreads());
+    this->GetMultiThreader()->SetNumberOfThreads(this->GetNumberOfWorkUnits());
     this->GetMultiThreader()->template ParallelizeImageRegion<OutputImageDimension>(
         this->GetOutput()->GetRequestedRegion(),
         [this](const OutputImageRegionType & outputRegionForThread)

Modules/Core/Common/include/itkImageTransformer.hxx

@@ -278,7 +278,7 @@ ImageTransformer< TInputImage >
   ThreadStruct str;
   str.Filter = this;
 
-  this->GetMultiThreader()->SetNumberOfThreads(this->GetNumberOfThreads());
+  this->GetMultiThreader()->SetNumberOfThreads(this->GetNumberOfWorkUnits());
   this->GetMultiThreader()->SetSingleMethod(callbackFunction, &str);
 
   this->GetMultiThreader()->SingleMethodExecute();

Modules/Core/Common/include/itkProcessObject.h

@@ -440,8 +440,8 @@ class ITKCommon_EXPORT ProcessObject:public Object
   itkBooleanMacro(ReleaseDataBeforeUpdateFlag);
 
   /** Get/Set the number of threads to create when executing. */
-  itkSetClampMacro(NumberOfThreads, ThreadIdType, 1, ITK_MAX_THREADS);
-  itkGetConstReferenceMacro(NumberOfThreads, ThreadIdType);
+  itkSetClampMacro(NumberOfWorkUnits, ThreadIdType, 1, ITK_MAX_THREADS);
+  itkGetConstReferenceMacro(NumberOfWorkUnits, ThreadIdType);
 
   /** Return the multithreader used by this class. */
   MultiThreaderType * GetMultiThreader() const
@@ -467,7 +467,7 @@ class ITKCommon_EXPORT ProcessObject:public Object
    *  thread.
    *
    * This class is the same as DomainThreader, but it uses the MultiThreader and
-   * NumberOfThreads defined on the enclosing ProcessObject.
+   * NumberOfWorkUnits defined on the enclosing ProcessObject.
    *
    * \sa DomainThreader
    * \ingroup ITKCommon
@@ -494,9 +494,9 @@ class ITKCommon_EXPORT ProcessObject:public Object
     ProcessObjectDomainThreader();
     virtual ~ProcessObjectDomainThreader();
 
-    /** This is overridden to set the MultiThreader and number of threads used
-     * the same as the ProcessObject. */
-    virtual void DetermineNumberOfThreadsUsed();
+    /** This is overridden to set the MultiThreader and number of
+     * work units used to be the same as in ProcessObject. */
+    virtual void DetermineNumberOfWorkUnitsUsed();
    };
 
   void PrintSelf(std::ostream & os, Indent indent) const override;
@@ -833,7 +833,7 @@ class ITKCommon_EXPORT ProcessObject:public Object
   /** Support processing data in multiple threads. Used by subclasses
    * (e.g., ImageSource). */
   MultiThreaderType::Pointer m_MultiThreader;
-  ThreadIdType               m_NumberOfThreads;
+  ThreadIdType               m_NumberOfWorkUnits;
 
   /** Memory management ivars */
   bool m_ReleaseDataBeforeUpdateFlag;

Modules/Core/Common/src/itkProcessObject.cxx

@@ -1336,7 +1336,7 @@ ::PrintSelf(std::ostream & os, Indent indent) const
     }
 
   os << indent << "NumberOfRequiredOutputs: " << m_NumberOfRequiredOutputs << std::endl;
-  os << indent << "Number Of Threads: " << m_NumberOfThreads << std::endl;
+  os << indent << "Number Of Work Units: " << m_NumberOfWorkUnits << std::endl;
   os << indent << "ReleaseDataFlag: "
      << ( this->GetReleaseDataFlag() ? "On" : "Off" ) << std::endl;
   os << indent << "ReleaseDataBeforeUpdateFlag: "
@@ -1665,20 +1665,20 @@ ::SetMultiThreader(MultiThreaderType* threader)
     if (this->m_MultiThreader.IsNull())
       {
       this->m_MultiThreader = threader;
-      m_NumberOfThreads = m_MultiThreader->GetNumberOfThreads();
+      m_NumberOfWorkUnits = m_MultiThreader->GetNumberOfThreads();
       }
     else
       {
       ThreadIdType oldDefaultNumber = m_MultiThreader->GetNumberOfThreads();
       this->m_MultiThreader = threader;
       ThreadIdType newDefaultNumber = m_MultiThreader->GetNumberOfThreads();
-      if (m_NumberOfThreads == oldDefaultNumber)
+      if (m_NumberOfWorkUnits == oldDefaultNumber)
         {
-        m_NumberOfThreads = newDefaultNumber;
+        m_NumberOfWorkUnits = newDefaultNumber;
         }
       else //clamp to new default
         {
-        m_NumberOfThreads = std::min(m_NumberOfThreads, newDefaultNumber);
+        m_NumberOfWorkUnits = std::min(m_NumberOfWorkUnits, newDefaultNumber);
         }
       }
     this->Modified();
@@ -1933,13 +1933,13 @@ ProcessObject::ProcessObjectDomainThreader< TDomainPartitioner, TAssociate >
 template< typename TDomainPartitioner, typename TAssociate >
 void
 ProcessObject::ProcessObjectDomainThreader< TDomainPartitioner, TAssociate >
-::DetermineNumberOfThreadsUsed()
+::DetermineNumberOfWorkUnitsUsed()
 {
   MultiThreaderBase * multiThreader = this->m_Associate->GetMultiThreader();
   this->SetMultiThreader( multiThreader );
-  multiThreader->SetNumberOfThreads( this->m_Associate->GetNumberOfThreads() );
+  multiThreader->SetNumberOfThreads( this->m_Associate->GetNumberOfWorkUnits() );
 
-  Superclass::DetermineNumberOfThreadsUsed();
+  Superclass::DetermineNumberOfWorkUnitsUsed();
 }
 
 

Modules/Core/Common/test/itkAtomicIntTest.cxx

@@ -243,7 +243,7 @@ int itkAtomicIntTest(int, char*[])
   itk::ModifiedTimeType beforeMTime = AnObject->GetMTime();
 
   mt->SetSingleMethod(MyFunction, nullptr);
-  mt->SetNumberOfThreads(NumThreads);
+  mt->SetNumberOfThreads( NumThreads );
   mt->SingleMethodExecute();
 
   mt->SetSingleMethod(MyFunction2, nullptr);

Modules/Core/Common/test/itkBarrierTest.cxx

@@ -29,13 +29,13 @@ class BarrierTestUserData
   itk::Barrier::Pointer m_SecondBarrier;
   unsigned int          m_Counter[ITK_MAX_THREADS];
   unsigned int          m_NumberOfIterations;
-  unsigned int          m_NumberOfThreads;
+  unsigned int          m_NumberOfWorkUnits;
   bool                  m_TestFailure;
 
   BarrierTestUserData( unsigned int number_of_threads)
   {
     m_TestFailure = false;
-    m_NumberOfThreads = number_of_threads;
+    m_NumberOfWorkUnits = number_of_threads;
     for (unsigned int i = 0; i < number_of_threads - 1; i++)
       { m_Counter[i] = 0; }
     m_NumberOfIterations = 50;
@@ -77,7 +77,7 @@ ITK_THREAD_RETURN_TYPE BarrierCheckIncrement( void *ptr )
     data->m_FirstBarrier->Wait();
 
     // Check the values in the m_Counter array
-    for (unsigned int j = 0; j < data->m_NumberOfThreads - 1; j++)
+    for (unsigned int j = 0; j < data->m_NumberOfWorkUnits - 1; j++)
       {
       if (data->m_Counter[j] != i)
         {
@@ -96,7 +96,7 @@ ITK_THREAD_RETURN_TYPE BarrierTestCallback( void *ptr )
   auto * data = static_cast<BarrierTestUserData *>(
                   ( (itk::PlatformMultiThreader::ThreadInfoStruct *)(ptr) )->UserData );
 
-  if (threadId == data->m_NumberOfThreads - 1)
+  if (threadId == data->m_NumberOfWorkUnits - 1)
     {
     BarrierCheckIncrement( ptr );
     }
@@ -142,7 +142,7 @@ int itkBarrierTest(int argc, char *argv[])
     //  {
     //  multithreader->GetModifiableThreadPool()->AddThreads(number_of_threads - maxThreads);
     //  }
-    multithreader->SetNumberOfThreads(number_of_threads);
+    multithreader->SetNumberOfThreads( number_of_threads );
     multithreader->SetSingleMethod( BarrierTestCallback, &data);
 
     for (unsigned int i = 0; i < 5; i++) //repeat test 5 times

Modules/Core/Common/test/itkCompensatedSummationTest2.cxx

@@ -60,7 +60,7 @@ class CompensatedSummationTest2Associate
   private:
     void BeforeThreadedExecution() override
       {
-      const itk::ThreadIdType numThreadsUsed = this->GetNumberOfThreadsUsed();
+      const itk::ThreadIdType numThreadsUsed = this->GetNumberOfWorkUnitsUsed();
       this->m_PerThreadCompensatedSum.resize( numThreadsUsed );
       for( itk::ThreadIdType i = 0; i < numThreadsUsed; ++i )
         {
@@ -84,7 +84,7 @@ class CompensatedSummationTest2Associate
       this->m_Associate->m_UncompensatedSumOfThreads = itk::NumericTraits<double>::ZeroValue();
       this->m_Associate->m_CompensatedSumOfThreads.ResetToZero();
 
-      for( itk::ThreadIdType i = 0, numThreadsUsed = this->GetNumberOfThreadsUsed(); i < numThreadsUsed; ++i )
+      for( itk::ThreadIdType i = 0, numThreadsUsed = this->GetNumberOfWorkUnitsUsed(); i < numThreadsUsed; ++i )
         {
         double sum = this->m_PerThreadCompensatedSum[i].GetSum();
         std::cout << i << ": " << sum << std::endl;
@@ -164,8 +164,8 @@ int itkCompensatedSummationTest2(int, char* [])
 
   /* Did we use as many threads as requested? */
   std::cout << "Requested numberOfThreads: " << numberOfThreads << std::endl
-            << "actual: threader->GetNumberOfThreadsUsed(): "
-            << domainThreader->GetNumberOfThreadsUsed() << "\n\n" << std::endl;
+            << "actual: threader->GetNumberOfWorkUnitsUsed(): "
+            << domainThreader->GetNumberOfWorkUnitsUsed() << "\n\n" << std::endl;
 
   /* Check results */
   if( itk::Math::NotAlmostEquals( enclosingClass.GetCompensatedSumOfThreads(), enclosingClass.GetUncompensatedSumOfThreads() ) )
@@ -193,10 +193,10 @@ int itkCompensatedSummationTest2(int, char* [])
     enclosingClass.Execute( domain );
 
     /* Check number of threads used */
-    if( domainThreader->GetNumberOfThreadsUsed() != maxNumberOfThreads )
+    if( domainThreader->GetNumberOfWorkUnitsUsed() != maxNumberOfThreads )
       {
       std::cerr << "Error: Expected to use " << maxNumberOfThreads
-                << "threads, but used " << domainThreader->GetNumberOfThreadsUsed()
+                << "threads, but used " << domainThreader->GetNumberOfWorkUnitsUsed()
                 << "." << std::endl;
       return EXIT_FAILURE;
       }

Modules/Core/Common/test/itkDataObjectAndProcessObjectTest.cxx

@@ -216,15 +216,15 @@ int itkDataObjectAndProcessObjectTest(int, char* [] )
   process->ReleaseDataBeforeUpdateFlagOn();
   TEST_SET_GET_VALUE( true, process->GetReleaseDataBeforeUpdateFlag() );
 
-  TEST_SET_GET_VALUE( itk::MultiThreaderBase::GetGlobalDefaultNumberOfThreads(), process->GetNumberOfThreads() );
-  process->SetNumberOfThreads( 11 );
-  TEST_SET_GET_VALUE( 11, process->GetNumberOfThreads() );
-  process->SetNumberOfThreads( 0 );
-  TEST_SET_GET_VALUE( 1, process->GetNumberOfThreads() );
-  process->SetNumberOfThreads( itk::NumericTraits<itk::ThreadIdType>::max() );
-  TEST_SET_GET_VALUE( itk::MultiThreaderBase::GetGlobalMaximumNumberOfThreads(), process->GetNumberOfThreads() );
-  process->SetNumberOfThreads( itk::MultiThreaderBase::GetGlobalDefaultNumberOfThreads() );
-  TEST_SET_GET_VALUE( itk::MultiThreaderBase::GetGlobalDefaultNumberOfThreads(), process->GetNumberOfThreads() );
+  TEST_SET_GET_VALUE( itk::MultiThreaderBase::GetGlobalDefaultNumberOfThreads(), process->GetNumberOfWorkUnits() );
+  process->SetNumberOfWorkUnits( 11 );
+  TEST_SET_GET_VALUE( 11, process->GetNumberOfWorkUnits() );
+  process->SetNumberOfWorkUnits( 0 );
+  TEST_SET_GET_VALUE( 1, process->GetNumberOfWorkUnits() );
+  process->SetNumberOfWorkUnits( itk::NumericTraits<itk::ThreadIdType>::max() );
+  TEST_SET_GET_VALUE( itk::MultiThreaderBase::GetGlobalMaximumNumberOfThreads(), process->GetNumberOfWorkUnits() );
+  process->SetNumberOfWorkUnits( itk::MultiThreaderBase::GetGlobalDefaultNumberOfThreads() );
+  TEST_SET_GET_VALUE( itk::MultiThreaderBase::GetGlobalDefaultNumberOfThreads(), process->GetNumberOfWorkUnits() );
 
   // not sure what to test with that method - at least test that it exist
   itk::MultiThreaderBase::Pointer multiThreader = process->GetMultiThreader();

Modules/Core/Common/test/itkThreadedIndexedContainerPartitionerTest.cxx

@@ -49,7 +49,7 @@ class DomainThreaderAssociate
   private:
     void BeforeThreadedExecution() override
       {
-      this->m_DomainInThreadedExecution.resize( this->GetNumberOfThreadsUsed() );
+      this->m_DomainInThreadedExecution.resize( this->GetNumberOfWorkUnitsUsed() );
       DomainType unsetDomain;
       unsetDomain.Fill( -1 );
       for(auto & i : m_DomainInThreadedExecution)
@@ -118,7 +118,7 @@ int ThreadedIndexedContainerPartitionerRunTest(
   domainThreader->GetMultiThreader();
   domainThreader->SetMaximumNumberOfThreads( numberOfThreads );
   // Possible if numberOfThreads < GlobalMaximumNumberOfThreads
-  if( domainThreader->GetMaximumNumberOfThreads() != numberOfThreads )
+  if( domainThreader->GetMaximumNumberOfThreads() < numberOfThreads )
     {
     std::cerr << "Failed setting requested number of threads: "
               << numberOfThreads << std::endl
@@ -131,14 +131,14 @@ int ThreadedIndexedContainerPartitionerRunTest(
 
   /* Did we use as many threads as requested? */
   std::cout << "Requested numberOfThreads: " << numberOfThreads << std::endl
-            << "actual: threader->GetNumberOfThreadsUsed(): "
-            << domainThreader->GetNumberOfThreadsUsed() << "\n\n" << std::endl;
+            << "actual: threader->GetNumberOfWorkUnitsUsed(): "
+            << domainThreader->GetNumberOfWorkUnitsUsed() << "\n\n" << std::endl;
 
   /* Check the results. */
   using DomainType = DomainThreaderAssociate::TestDomainThreader::DomainType;
   DomainType::IndexValueType previousEndIndex = -1;
   const std::vector< DomainType > domainInThreadedExecution = domainThreader->GetDomainInThreadedExecution();
-  for( itk::ThreadIdType i = 0; i < domainThreader->GetNumberOfThreadsUsed(); ++i )
+  for( itk::ThreadIdType i = 0; i < domainThreader->GetNumberOfWorkUnitsUsed(); ++i )
     {
     DomainType subRange = domainInThreadedExecution[i];
     /* Check that the sub range was assigned something at all */
@@ -244,10 +244,10 @@ int itkThreadedIndexedContainerPartitionerTest(int, char* [])
       {
       return EXIT_FAILURE;
       }
-    if( domainThreader->GetNumberOfThreadsUsed() != maxNumberOfThreads-1 )
+    if( domainThreader->GetNumberOfWorkUnitsUsed() != maxNumberOfThreads-1 )
       {
       std::cerr << "Error: Expected to use only " << maxNumberOfThreads-1
-                << "threads, but used " << domainThreader->GetNumberOfThreadsUsed()
+                << "threads, but used " << domainThreader->GetNumberOfWorkUnitsUsed()
                 << "." << std::endl;
       }
     }