Slic3r::GUI::BoostThreadWorker Class Reference

#include </home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/Jobs/BoostThreadWorker.hpp>

Inheritance diagram for Slic3r::GUI::BoostThreadWorker:

Collaboration diagram for Slic3r::GUI::BoostThreadWorker:

Classes
struct	JobEntry
struct	StatusInfo
struct	MainThreadCallData
struct	EmptyMessage
class	WorkerMessage

Public Member Functions
	BoostThreadWorker (std::shared_ptr< ProgressIndicator > pri, boost::thread::attributes &attr, const char *name="")
	BoostThreadWorker (std::shared_ptr< ProgressIndicator > pri, boost::thread::attributes &&attr, const char *name="")
	BoostThreadWorker (std::shared_ptr< ProgressIndicator > pri, const char *name="")
	~BoostThreadWorker ()
	BoostThreadWorker (const BoostThreadWorker &)=delete
	BoostThreadWorker (BoostThreadWorker &&)=delete
BoostThreadWorker &	operator= (const BoostThreadWorker &)=delete
BoostThreadWorker &	operator= (BoostThreadWorker &&)=delete
bool	push (std::shared_ptr< Job > job) override
bool	is_idle () const override
void	cancel () override
void	cancel_all () override
ProgressIndicator *	get_pri ()
const ProgressIndicator *	get_pri () const
void	clear_percent () override
void	show_error_info (const std::string &msg, int code, const std::string &description, const std::string &extra) override
void	process_events () override
bool	wait_for_current_job (unsigned timeout_ms=0) override
bool	wait_for_idle (unsigned timeout_ms=0) override

Protected Member Functions
void	update_status (int st, const std::string &msg="") override
bool	was_canceled () const override
std::future< void >	call_on_main_thread (std::function< void()> fn) override

Private Types
using	JobQueue = ThreadSafeQueueSPSC<JobEntry>
using	MessageQueue = ThreadSafeQueueSPSC<WorkerMessage>

Private Member Functions
void	run ()
bool	join (int timeout_ms=0)

Private Attributes
boost::thread	m_thread
std::atomic< bool >	m_running {false}
std::atomic< bool >	m_canceled {false}
std::shared_ptr< ProgressIndicator >	m_progress
JobQueue	m_input_queue
MessageQueue	m_output_queue
std::string	m_name

Detailed Description

---

Class Documentation

Slic3r::GUI::BoostThreadWorker::JobEntry

struct Slic3r::GUI::BoostThreadWorker::JobEntry

Collaboration diagram for Slic3r::GUI::BoostThreadWorker::JobEntry:

Class Members
bool	canceled = false
exception_ptr	eptr = nullptr
shared_ptr< Job >	job

Slic3r::GUI::BoostThreadWorker::StatusInfo

struct Slic3r::GUI::BoostThreadWorker::StatusInfo

Collaboration diagram for Slic3r::GUI::BoostThreadWorker::StatusInfo:

Class Members
string	msg
int	status

Slic3r::GUI::BoostThreadWorker::MainThreadCallData

struct Slic3r::GUI::BoostThreadWorker::MainThreadCallData

Class Members
function< void()>	fn
promise< void >	promise

Slic3r::GUI::BoostThreadWorker::EmptyMessage

struct Slic3r::GUI::BoostThreadWorker::EmptyMessage

Member Typedef Documentation

JobQueue

using Slic3r::GUI::BoostThreadWorker::JobQueue = ThreadSafeQueueSPSC<JobEntry>

private

MessageQueue

using Slic3r::GUI::BoostThreadWorker::MessageQueue = ThreadSafeQueueSPSC<WorkerMessage>

private

Constructor & Destructor Documentation

BoostThreadWorker() [1/5]

Slic3r::GUI::BoostThreadWorker::BoostThreadWorker ( std::shared_ptr< ProgressIndicator > pri, boost::thread::attributes & attr, const char * name = "" )

explicit

    : m_progress(std::move(pri)), m_name{name}
{
    if (m_progress)
        m_progress->set_cancel_callback([this](){ cancel(); });
 
    m_thread = create_thread(attribs, [this] { this->run(); });
 
    std::string nm{name};
    if (!nm.empty()) set_thread_name(m_thread, name);
}

References Slic3r::create_thread(), m_name, m_progress, m_thread, run(), and Slic3r::set_thread_name().

Referenced by BoostThreadWorker(), BoostThreadWorker(), BoostThreadWorker(), BoostThreadWorker(), Slic3r::GUI::BoostThreadWorker::WorkerMessage::deliver(), operator=(), and operator=().

Here is the call graph for this function:

Here is the caller graph for this function:

BoostThreadWorker() [2/5]

Slic3r::GUI::BoostThreadWorker::BoostThreadWorker ( std::shared_ptr< ProgressIndicator > pri, boost::thread::attributes && attr, const char * name = "" )

inlineexplicit

        : BoostThreadWorker{std::move(pri), attr, name}
    {}

References BoostThreadWorker().

Here is the call graph for this function:

BoostThreadWorker() [3/5]

Slic3r::GUI::BoostThreadWorker::BoostThreadWorker ( std::shared_ptr< ProgressIndicator > pri, const char * name = "" )

inlineexplicit

        : BoostThreadWorker{std::move(pri), {}, name}
    {}

References BoostThreadWorker().

Here is the call graph for this function:

~BoostThreadWorker()

Slic3r::GUI::BoostThreadWorker::~BoostThreadWorker

(

)

{
    bool joined = false;
    try {
        cancel_all();
        wait_for_idle(ABORT_WAIT_MAX_MS);
        m_input_queue.push(JobEntry{nullptr});
        joined = join(ABORT_WAIT_MAX_MS);
    } catch(...) {}
 
    if (!joined)
        BOOST_LOG_TRIVIAL(error)
            << "Could not join worker thread '" << m_name << "'";
}

References Slic3r::GUI::ABORT_WAIT_MAX_MS, cancel_all(), join(), m_input_queue, m_name, and wait_for_idle().

Here is the call graph for this function:

BoostThreadWorker() [4/5]

Slic3r::GUI::BoostThreadWorker::BoostThreadWorker ( const BoostThreadWorker & )

delete

References BoostThreadWorker().

Here is the call graph for this function:

BoostThreadWorker() [5/5]

Slic3r::GUI::BoostThreadWorker::BoostThreadWorker ( BoostThreadWorker && )

delete

References BoostThreadWorker().

Here is the call graph for this function:

Member Function Documentation

call_on_main_thread()

std::future< void > Slic3r::GUI::BoostThreadWorker::call_on_main_thread ( std::function< void()> fn )

overrideprotectedvirtual

Implements Slic3r::GUI::Job::Ctl.

{
    MainThreadCallData cbdata{std::move(fn), {}};
    std::future<void> future = cbdata.promise.get_future();
 
    m_output_queue.push(std::move(cbdata));
 
    return future;
}

References m_output_queue, and Slic3r::GUI::BoostThreadWorker::MainThreadCallData::promise.

cancel()

void Slic3r::GUI::BoostThreadWorker::cancel ( )

inlineoverridevirtual

Implements Slic3r::GUI::Worker.

{ m_canceled.store(true); }

References m_canceled.

Referenced by cancel_all().

Here is the caller graph for this function:

cancel_all()

void Slic3r::GUI::BoostThreadWorker::cancel_all ( )

inlineoverridevirtual

Implements Slic3r::GUI::Worker.

{ m_input_queue.clear(); cancel(); }

References cancel(), and m_input_queue.

Referenced by ~BoostThreadWorker().

Here is the call graph for this function:

Here is the caller graph for this function:

clear_percent()

void Slic3r::GUI::BoostThreadWorker::clear_percent ( )

inlineoverridevirtual

Implements Slic3r::GUI::Job::Ctl.

    {
        if (m_progress) {
            m_progress->clear_percent();
        }
    }

References m_progress.

get_pri() [1/2]

ProgressIndicator * Slic3r::GUI::BoostThreadWorker::get_pri ( )

inline

{ return m_progress.get(); }

References m_progress.

Referenced by Slic3r::GUI::BoostThreadWorker::WorkerMessage::deliver().

Here is the caller graph for this function:

get_pri() [2/2]

const ProgressIndicator * Slic3r::GUI::BoostThreadWorker::get_pri ( ) const

inline

{ return m_progress.get(); }

References m_progress.

is_idle()

bool Slic3r::GUI::BoostThreadWorker::is_idle ( ) const

inlineoverridevirtual

Implements Slic3r::GUI::Worker.

    {
        // The assumption is that jobs can only be queued from a single main
        // thread from which this method is also called. And the output
        // messages are also processed only in this calling thread. In that
        // case, if the input queue is empty, it will remain so during this
        // function call. If the worker thread is also not running and the
        // output queue is already processed, we can safely say that the
        // worker is dormant.
        return m_input_queue.empty() && !m_running.load() && m_output_queue.empty();
    }

References m_input_queue, m_output_queue, and m_running.

Referenced by wait_for_current_job(), and wait_for_idle().

Here is the caller graph for this function:

join()

bool Slic3r::GUI::BoostThreadWorker::join ( int timeout_ms = 0 )

private

{
    if (!m_thread.joinable())
        return true;
 
    if (timeout_ms <= 0) {
        m_thread.join();
    }
    else if (m_thread.try_join_for(boost::chrono::milliseconds(timeout_ms))) {
        return true;
    }
    else
        return false;
 
    return true;
}

References m_thread.

Referenced by ~BoostThreadWorker().

Here is the caller graph for this function:

operator=() [1/2]

BoostThreadWorker & Slic3r::GUI::BoostThreadWorker::operator= ( BoostThreadWorker && )

delete

References BoostThreadWorker(), and push().

Here is the call graph for this function:

operator=() [2/2]

BoostThreadWorker & Slic3r::GUI::BoostThreadWorker::operator= ( const BoostThreadWorker & )

delete

References BoostThreadWorker().

Here is the call graph for this function:

process_events()

void Slic3r::GUI::BoostThreadWorker::process_events ( )

overridevirtual

Implements Slic3r::GUI::Worker.

{
    while (m_output_queue.consume_one([this](WorkerMessage &msg) {
        msg.deliver(*this);
    }));
}

References m_output_queue.

push()

bool Slic3r::GUI::BoostThreadWorker::push ( std::shared_ptr< Job > job )

overridevirtual

Implements Slic3r::GUI::Worker.

{
    if (!job)
        return false;
 
    m_input_queue.push(JobEntry{std::move(job)});
    return true;
}

References m_input_queue.

Referenced by operator=().

Here is the caller graph for this function:

run()

void Slic3r::GUI::BoostThreadWorker::run ( )

private

{
    bool stop = false;
    while (!stop) {
        m_input_queue
            .consume_one(BlockingWait{0, &m_running}, [this, &stop](JobEntry &e) {
                if (!e.job)
                    stop = true;
                else {
                    m_canceled.store(false);
 
                    try {
                        e.job->process(*this);
                    } catch (...) {
                        e.eptr = std::current_exception();
                    }
 
                    e.canceled = m_canceled.load();
                    m_output_queue.push(std::move(e)); // finalization message
                }
                m_running.store(false);
            });
    };
}

References m_canceled, m_input_queue, m_output_queue, and m_running.

Referenced by BoostThreadWorker().

Here is the caller graph for this function:

show_error_info()

void Slic3r::GUI::BoostThreadWorker::show_error_info ( const std::string & msg, int code, const std::string & description, const std::string & extra )

inlineoverridevirtual

Implements Slic3r::GUI::Job::Ctl.

    {
        if (m_progress) {
            m_progress->show_error_info(from_u8(msg), code, from_u8(description), from_u8(extra));
        }
    }

References Slic3r::GUI::from_u8(), and m_progress.

Here is the call graph for this function:

update_status()

void Slic3r::GUI::BoostThreadWorker::update_status ( int st, const std::string & msg = "" )

overrideprotectedvirtual

Implements Slic3r::GUI::Job::Ctl.

{
    m_output_queue.push(st, msg);
}

References m_output_queue.

wait_for_current_job()

bool Slic3r::GUI::BoostThreadWorker::wait_for_current_job ( unsigned timeout_ms = 0 )

overridevirtual

Implements Slic3r::GUI::Worker.

{
    bool ret = true;
 
    if (!is_idle()) {
        bool was_finish = false;
        bool timeout_reached = false;
        while (!timeout_reached && !was_finish) {
            timeout_reached =
                !m_output_queue.consume_one(BlockingWait{timeout_ms},
                                            [this, &was_finish](
                                                WorkerMessage &msg) {
                                                msg.deliver(*this);
                                                if (msg.get_type() ==
                                                    WorkerMessage::Finalize)
                                                    was_finish = true;
                                            });
        }
 
        ret = !timeout_reached;
    }
 
    return ret;
}

References Slic3r::GUI::BoostThreadWorker::WorkerMessage::Finalize, is_idle(), and m_output_queue.

Here is the call graph for this function:

wait_for_idle()

bool Slic3r::GUI::BoostThreadWorker::wait_for_idle ( unsigned timeout_ms = 0 )

overridevirtual

Implements Slic3r::GUI::Worker.

{
    bool timeout_reached = false;
    while (!timeout_reached && !is_idle()) {
        timeout_reached = !m_output_queue
                               .consume_one(BlockingWait{timeout_ms},
                                            [this](WorkerMessage &msg) {
                                                msg.deliver(*this);
                                            });
    }
 
    return !timeout_reached;
}

References is_idle(), and m_output_queue.

Referenced by ~BoostThreadWorker().

Here is the call graph for this function:

Here is the caller graph for this function:

was_canceled()

bool Slic3r::GUI::BoostThreadWorker::was_canceled ( ) const

inlineoverrideprotectedvirtual

Implements Slic3r::GUI::Job::Ctl.

{ return m_canceled.load(); }

References m_canceled.

Member Data Documentation

m_canceled

std::atomic<bool> Slic3r::GUI::BoostThreadWorker::m_canceled {false}

private

{false}, m_canceled{false};

Referenced by cancel(), run(), and was_canceled().

m_input_queue

JobQueue Slic3r::GUI::BoostThreadWorker::m_input_queue

private

Referenced by ~BoostThreadWorker(), cancel_all(), is_idle(), push(), and run().

m_name

std::string Slic3r::GUI::BoostThreadWorker::m_name

private

Referenced by BoostThreadWorker(), and ~BoostThreadWorker().

m_output_queue

MessageQueue Slic3r::GUI::BoostThreadWorker::m_output_queue

private

Referenced by call_on_main_thread(), is_idle(), process_events(), run(), update_status(), wait_for_current_job(), and wait_for_idle().

m_progress

std::shared_ptr<ProgressIndicator> Slic3r::GUI::BoostThreadWorker::m_progress

private

Referenced by BoostThreadWorker(), clear_percent(), get_pri(), get_pri(), and show_error_info().

m_running

std::atomic<bool> Slic3r::GUI::BoostThreadWorker::m_running {false}

private

{false}, m_canceled{false};

Referenced by is_idle(), and run().

m_thread

boost::thread Slic3r::GUI::BoostThreadWorker::m_thread

private

Referenced by BoostThreadWorker(), and join().

---

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

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/Jobs/BoostThreadWorker.hpp
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/Jobs/BoostThreadWorker.cpp