ThreadPool1.hxx

Go to the documentation of this file.

/*--------------------------------------------------------------------------*\
 |                                                                          |
 |  Copyright (C) 2020                                                      |
 |                                                                          |
 |         , __                 , __                                        |
 |        /|/  \               /|/  \                                       |
 |         | __/ _   ,_         | __/ _   ,_                                |
 |         |   \|/  /  |  |   | |   \|/  /  |  |   |                        |
 |         |(__/|__/   |_/ \_/|/|(__/|__/   |_/ \_/|/                       |
 |                           /|                   /|                        |
 |                           \|                   \|                        |
 |                                                                          |
 |      Enrico Bertolazzi                                                   |
 |      Dipartimento di Ingegneria Industriale                              |
 |      Università degli Studi di Trento                                    |
 |      email: enrico.bertolazzi@unitn.it                                   |
 |                                                                          |
\*--------------------------------------------------------------------------*/
 
//
// file: ThreadPool1.hxx
//
 
namespace Utils {

 
  /*\
   |   _____ _                        _ ____             _
   |  |_   _| |__  _ __ ___  __ _  __| |  _ \ ___   ___ | |
   |    | | | '_ \| '__/ _ \/ _` |/ _` | |_) / _ \ / _ \| |
   |    | | | | | | | |  __/ (_| | (_| |  __/ (_) | (_) | |
   |    |_| |_| |_|_|  \___|\__,_|\__,_|_|   \___/ \___/|_|
  \*/

  class ThreadPool1 : public ThreadPoolBase {
 
    using FUN = ThreadPoolBase::FUN;
    //using PFUN = ThreadPoolBase::PFUN;
 
    /*\
     |  __        __         _
     |  \ \      / /__  _ __| | _____ _ __
     |   \ \ /\ / / _ \| '__| |/ / _ \ '__|
     |    \ V  V / (_) | |  |   <  __/ |
     |     \_/\_/ \___/|_|  |_|\_\___|_|
    \*/
    class Worker {
 
      std::mutex              m_task_mutex;
      std::condition_variable m_task_cv;
 
      bool        m_active{true};     
      std::thread m_running_thread;   
      bool        m_task_done{true};  
      FUN         m_task;             

      void
      worker_loop() {
        std::unique_lock<std::mutex> lock(m_task_mutex);
        while ( m_active ) {
          while ( m_task_done ) m_task_cv.wait( lock );
          m_task();
          m_task_done = true;
          m_task_cv.notify_one();
        }
      }
 
    public:
 
      //disable copy
      Worker( Worker const & )              = delete;
      //Worker( Worker && )                   = delete;
      Worker& operator = ( Worker const & ) = delete;
      Worker& operator = ( Worker && )      = delete;

      Worker() : m_running_thread( std::thread( &Worker::worker_loop, this ) ) {}

      ~Worker() {
        auto dummy_task = []()->void{};
        m_active = false; // deactivate computation
        exec( dummy_task );
        if ( m_running_thread.joinable() ) m_running_thread.join(); // wait thread for exiting
      }
      
      Worker( Worker && rhs ) noexcept
      : m_active(rhs.m_active)
      , m_running_thread(std::move(rhs.m_running_thread))
      , m_task(std::move(rhs.m_task))
      {}

      void
      wait() {
        std::unique_lock<std::mutex> lock(m_task_mutex);
        while ( !m_task_done ) m_task_cv.wait( lock );
      }

      void
      exec( FUN && fun ) {
        // aspetto che pointer si liberi se occupato
        std::unique_lock<std::mutex> lock(m_task_mutex);
        while ( !m_task_done ) m_task_cv.wait( lock );
        m_task_done = false;
        m_task = std::move(fun); // cambia funzione da eseguire
        m_task_cv.notify_one();
      }
    };

    std::size_t m_thread_to_send{0};

    std::vector<Worker> m_workers;
 
  public:

    explicit
    ThreadPool1(
      unsigned nthread = std::max(
        unsigned(1),
        unsigned(std::thread::hardware_concurrency()-1)
      )
    ) : ThreadPoolBase(), m_workers( size_t( nthread ) ) { }

    virtual
    ~ThreadPool1() { m_workers.clear(); }

    void
    exec( FUN && fun ) override {
      m_workers[m_thread_to_send].exec( std::move(fun) );
      if ( ++m_thread_to_send >= m_workers.size() ) m_thread_to_send = 0;
    }

    void wait() override { for ( auto && w : m_workers ) w.wait(); }

    unsigned thread_count() const override { return unsigned(m_workers.size()); }
 
    static char const * Name() { return "ThreadPool1"; } 
 
    char const * name() const override { return Name(); }
 
  };

 
}
 
//
// eof: ThreadPool1.hxx
//