vtkSMPThreadPool.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-License-Identifier: BSD-3-Clause
// .NAME vtkSMPThreadPool - A thread pool implementation using std::thread
//
// .SECTION Description
// vtkSMPThreadPool class creates a thread pool of std::thread, the number
// of thread must be specified at the initialization of the class.
// The DoJob() method is used attributes the job to a free thread, if all
// threads are working, the job is kept in a queue. Note that vtkSMPThreadPool
// destructor joins threads and finish the jobs in the queue.
 
#ifndef vtkSMPThreadPool_h
#define vtkSMPThreadPool_h
 
#include "vtkCommonCoreModule.h" // For export macro
#include "vtkSystemIncludes.h"
 
#include <atomic>     // For std::atomic
#include <functional> // For std::function
#include <mutex>      // For std::unique_lock
#include <thread>     // For std::thread
#include <vector>     // For std::vector
 
namespace vtk
{
namespace detail
{
namespace smp
{
VTK_ABI_NAMESPACE_BEGIN
 
class VTKCOMMONCORE_EXPORT vtkSMPThreadPool
{
  // Internal data structures
  struct ThreadJob;
  struct ThreadData;
  struct ProxyThreadData;
  struct ProxyData;
 
public:
  class VTKCOMMONCORE_EXPORT Proxy final
  {
  public:
    ~Proxy();
    Proxy(const Proxy&) = delete;
    Proxy& operator=(const Proxy&) = delete;
    Proxy(Proxy&&) noexcept;
    Proxy& operator=(Proxy&&) noexcept;
 
    void Join();
 
    void DoJob(std::function<void()> job);
 
    std::vector<std::reference_wrapper<std::thread>> GetThreads() const;
 
    bool IsTopLevel() const noexcept;
 
  private:
    friend class vtkSMPThreadPool; // Only the thread pool can construct this object
 
    Proxy(std::unique_ptr<ProxyData>&& data);
 
    std::unique_ptr<ProxyData> Data;
  };
 
  vtkSMPThreadPool();
  ~vtkSMPThreadPool();
  vtkSMPThreadPool(const vtkSMPThreadPool&) = delete;
  vtkSMPThreadPool& operator=(const vtkSMPThreadPool&) = delete;
 
  Proxy AllocateThreads(std::size_t threadCount = 0);
 
  static constexpr std::size_t ExternalThreadID = 1;
 
  std::size_t GetThreadId() const noexcept;
 
  bool IsParallelScope() const noexcept;
 
  bool GetSingleThread() const;
 
  std::size_t ThreadCount() const noexcept;
 
private:
  // static because also used by proxy
  static void RunJob(ThreadData& data, std::size_t jobIndex, std::unique_lock<std::mutex>& lock);
 
  ThreadData* GetCallerThreadData() const noexcept;
 
  std::thread MakeThread();
  void FillThreadsForNestedProxy(ProxyData* proxy, std::size_t maxCount);
  std::size_t GetNextThreadId() noexcept;
 
  std::atomic<bool> Initialized{};
  std::atomic<bool> Joining{};
  std::vector<std::unique_ptr<ThreadData>> Threads; // Thread pool, fixed size
  std::atomic<std::size_t> NextProxyThreadId{ 1 };
 
public:
  static vtkSMPThreadPool& GetInstance();
};
 
VTK_ABI_NAMESPACE_END
} // namespace smp
} // namespace detail
} // namespace vtk
 
#endif
/* VTK-HeaderTest-Exclude: vtkSMPThreadPool.h */