eonc::detail::ImagePool Class Reference

#include <ForEachImage.h>

Public Member Functions
	ImagePool (const ImagePool &)=delete
ImagePool &	operator= (const ImagePool &)=delete
	~ImagePool ()
void	run (long n, const std::function< void(long)> &work)
std::size_t	threads () const noexcept
void	ensureThreads (std::size_t n)

Static Public Member Functions
static ImagePool &	instance ()

Private Member Functions
	ImagePool ()
void	drain ()
void	loop (long index)

Static Private Member Functions
static void	serial (long n, const std::function< void(long)> &work)

Private Attributes
std::vector< std::thread >	threads_
std::mutex	runMutex_
std::mutex	mutex_
std::condition_variable	wake_
std::condition_variable	done_
const std::function< void(long)> *	work_ {nullptr}
long	n_ {0}
std::atomic< long >	next_ {1}
std::exception_ptr	failure_
long	helpers_ {0}
long	active_ {0}
std::size_t	generation_ {0}
bool	stop_ {false}

Detailed Description

Definition at line 44 of file ForEachImage.h.

Constructor & Destructor Documentation

ImagePool() [1/2]

eonc::detail::ImagePool::ImagePool ( const ImagePool & )

delete

~ImagePool()

eonc::detail::ImagePool::~ImagePool ( )

inline

Definition at line 54 of file ForEachImage.h.

               {
    {
      std::lock_guard<std::mutex> lock(mutex_);
      stop_ = true;
    }
    wake_.notify_all();
    for (auto &t : threads_)
      t.join();
  }

ImagePool() [2/2]

eonc::detail::ImagePool::ImagePool ( )

inlineprivate

Definition at line 111 of file ForEachImage.h.

              {
    const long helpers = usableCores() - 1;
    for (long t = 0; t < helpers; t++) {
      try {
        threads_.emplace_back([this, t] { loop(t); });
      } catch (...) {
        break; // the threads already running serve every band
      }
    }
  }

Member Function Documentation

drain()

void eonc::detail::ImagePool::drain ( )

inlineprivate

Definition at line 136 of file ForEachImage.h.

               {
    for (long i = next_.fetch_add(1); i <= n_; i = next_.fetch_add(1)) {
      try {
        (*work_)(i);
      } catch (...) {
        std::lock_guard<std::mutex> lock(mutex_);
        if (!failure_)
          failure_ = std::current_exception();
      }
    }
  }

ensureThreads()

void eonc::detail::ImagePool::ensureThreads ( std::size_t n )

inline

Definition at line 98 of file ForEachImage.h.

                                  {
    std::lock_guard<std::mutex> busy(runMutex_);
    while (threads_.size() < n) {
      const long index = static_cast<long>(threads_.size());
      try {
        threads_.emplace_back([this, index] { loop(index); });
      } catch (...) {
        break;
      }
    }
  }

instance()

ImagePool & eonc::detail::ImagePool::instance ( )

inlinestatic

Definition at line 46 of file ForEachImage.h.

                               {
    static ImagePool pool;
    return pool;
  }

loop()

void eonc::detail::ImagePool::loop ( long index )

inlineprivate

Definition at line 148 of file ForEachImage.h.

                        {
    std::size_t seen = 0;
    for (;;) {
      {
        std::unique_lock<std::mutex> lock(mutex_);
        wake_.wait(lock, [&] {
          return stop_ || (generation_ != seen && index < helpers_);
        });
        if (stop_)
          return;
        seen = generation_;
      }
      drain();
      {
        std::lock_guard<std::mutex> lock(mutex_);
        if (--active_ == 0)
          done_.notify_one();
      }
    }
  }

operator=()

ImagePool & eonc::detail::ImagePool::operator= ( const ImagePool & )

delete

run()

void eonc::detail::ImagePool::run ( long n, const std::function< void(long)> & work )

inline

Definition at line 66 of file ForEachImage.h.

                                                        {
    if (n <= 0)
      return;
    std::unique_lock<std::mutex> busy(runMutex_, std::try_to_lock);
    if (!busy.owns_lock() || threads_.empty() || n == 1) {
      serial(n, work);
      return;
    }
    {
      std::lock_guard<std::mutex> lock(mutex_);
      work_ = &work;
      n_ = n;
      next_.store(1);
      failure_ = nullptr;
      // Only as many helpers as there are images beyond the caller's.
      helpers_ = std::min<long>(static_cast<long>(threads_.size()), n - 1);
      active_ = helpers_;
      ++generation_;
    }
    wake_.notify_all();
    drain();
    std::unique_lock<std::mutex> lock(mutex_);
    done_.wait(lock, [this] { return active_ == 0; });
    work_ = nullptr;
    if (failure_)
      std::rethrow_exception(failure_);
  }

serial()

void eonc::detail::ImagePool::serial ( long n, const std::function< void(long)> & work )

inlinestaticprivate

Definition at line 122 of file ForEachImage.h.

                                                                  {
    std::exception_ptr failure;
    for (long i = 1; i <= n; i++) {
      try {
        work(i);
      } catch (...) {
        if (!failure)
          failure = std::current_exception();
      }
    }
    if (failure)
      std::rethrow_exception(failure);
  }

threads()

std::size_t eonc::detail::ImagePool::threads ( ) const

inlinenodiscardnoexcept

Definition at line 94 of file ForEachImage.h.

{ return threads_.size(); }

Member Data Documentation

active_

long eonc::detail::ImagePool::active_ {0}

private

Definition at line 179 of file ForEachImage.h.

{0};

done_

std::condition_variable eonc::detail::ImagePool::done_

private

Definition at line 173 of file ForEachImage.h.

failure_

std::exception_ptr eonc::detail::ImagePool::failure_

private

Definition at line 177 of file ForEachImage.h.

generation_

std::size_t eonc::detail::ImagePool::generation_ {0}

private

Definition at line 180 of file ForEachImage.h.

{0};

helpers_

long eonc::detail::ImagePool::helpers_ {0}

private

Definition at line 178 of file ForEachImage.h.

{0};

mutex_

std::mutex eonc::detail::ImagePool::mutex_

private

Definition at line 171 of file ForEachImage.h.

n_

long eonc::detail::ImagePool::n_ {0}

private

Definition at line 175 of file ForEachImage.h.

{0};

next_

std::atomic<long> eonc::detail::ImagePool::next_ {1}

private

Definition at line 176 of file ForEachImage.h.

{1};

runMutex_

std::mutex eonc::detail::ImagePool::runMutex_

private

Definition at line 170 of file ForEachImage.h.

stop_

bool eonc::detail::ImagePool::stop_ {false}

private

Definition at line 181 of file ForEachImage.h.

{false};

threads_

std::vector<std::thread> eonc::detail::ImagePool::threads_

private

Definition at line 169 of file ForEachImage.h.

wake_

std::condition_variable eonc::detail::ImagePool::wake_

private

Definition at line 172 of file ForEachImage.h.

work_

const std::function<void(long)>* eonc::detail::ImagePool::work_ {nullptr}

private

Definition at line 174 of file ForEachImage.h.

{nullptr};

---

The documentation for this class was generated from the following file:

• /home/runner/work/eOn/eOn/client/ForEachImage.h