141 lines
4.8 KiB
C++
141 lines
4.8 KiB
C++
#ifndef PRUSALSICER_WORKER_HPP
|
|
#define PRUSALSICER_WORKER_HPP
|
|
|
|
#include <memory>
|
|
|
|
#include "JobNew.hpp"
|
|
|
|
namespace Slic3r { namespace GUI {
|
|
// #define EXECUTE_UPDATE_ON_MAIN_THREAD // debug execution on main thread
|
|
// An interface of a worker that runs jobs on a dedicated worker thread, one
|
|
// after the other. It is assumed that every method of this class is called
|
|
// from the same main thread.
|
|
|
|
#ifdef EXECUTE_UPDATE_ON_MAIN_THREAD
|
|
namespace {
|
|
// Run Job on main thread (blocking) - ONLY DEBUG
|
|
static inline bool execute_job(std::shared_ptr<JobNew> j)
|
|
{
|
|
struct MyCtl : public JobNew::Ctl
|
|
{
|
|
void update_status(int st, const std::string &msg = "") override{};
|
|
bool was_canceled() const override { return false; }
|
|
std::future<void> call_on_main_thread(std::function<void()> fn) override { return std::future<void>{}; }
|
|
} ctl;
|
|
j->process(ctl);
|
|
wxGetApp().plater()->CallAfter([j]() {
|
|
std::exception_ptr e_ptr = nullptr;
|
|
j->finalize(false, e_ptr);
|
|
});
|
|
return true;
|
|
}
|
|
} // namespace
|
|
#endif
|
|
class Worker {
|
|
public:
|
|
// Queue up a new job after the current one. This call does not block.
|
|
// Returns false if the job gets discarded.
|
|
virtual bool push(std::unique_ptr<JobNew> job) = 0;
|
|
|
|
// Returns true if no job is running, the job queue is empty and no job
|
|
// message is left to be processed. This means that nothing is left to
|
|
// finalize or take care of in the main thread.
|
|
virtual bool is_idle() const = 0;
|
|
|
|
// Ask the current job gracefully to cancel. This call is not blocking and
|
|
// the job may or may not cancel eventually, depending on its
|
|
// implementation. Note that it is not trivial to kill a thread forcefully
|
|
// and we don't need that.
|
|
virtual void cancel() = 0;
|
|
|
|
// This method will delete the queued jobs and cancel the current one.
|
|
virtual void cancel_all() = 0;
|
|
|
|
// Needs to be called continuously to process events (like status update
|
|
// or finalizing of jobs) in the main thread. This can be done e.g. in a
|
|
// wxIdle handler.
|
|
virtual void process_events() = 0;
|
|
|
|
// Wait until the current job finishes. Timeout will only be considered
|
|
// if not zero. Returns false if timeout is reached but the job has not
|
|
// finished.
|
|
virtual bool wait_for_current_job(unsigned timeout_ms = 0) = 0;
|
|
|
|
// Wait until the whole job queue finishes. Timeout will only be considered
|
|
// if not zero. Returns false only if timeout is reached but the worker has
|
|
// not reached the idle state.
|
|
virtual bool wait_for_idle(unsigned timeout_ms = 0) = 0;
|
|
|
|
// The destructor shall properly close the worker thread.
|
|
virtual ~Worker() = default;
|
|
};
|
|
|
|
template<class Fn> constexpr bool IsProcessFn = std::is_invocable_v<Fn, JobNew::Ctl&>;
|
|
template<class Fn> constexpr bool IsFinishFn = std::is_invocable_v<Fn, bool, std::exception_ptr&>;
|
|
|
|
// Helper function to use the worker with arbitrary functors.
|
|
template<class ProcessFn, class FinishFn,
|
|
class = std::enable_if_t<IsProcessFn<ProcessFn>>,
|
|
class = std::enable_if_t<IsFinishFn<FinishFn>> >
|
|
bool queue_job(Worker &w, ProcessFn fn, FinishFn finishfn)
|
|
{
|
|
struct LambdaJob: JobNew {
|
|
ProcessFn fn;
|
|
FinishFn finishfn;
|
|
|
|
LambdaJob(ProcessFn pfn, FinishFn ffn)
|
|
: fn{std::move(pfn)}, finishfn{std::move(ffn)}
|
|
{}
|
|
|
|
void process(Ctl &ctl) override { fn(ctl); }
|
|
void finalize(bool canceled, std::exception_ptr &eptr) override
|
|
{
|
|
finishfn(canceled, eptr);
|
|
}
|
|
};
|
|
|
|
auto j = std::make_unique<LambdaJob>(std::move(fn), std::move(finishfn));
|
|
return w.push(std::move(j));
|
|
}
|
|
|
|
template<class ProcessFn, class = std::enable_if_t<IsProcessFn<ProcessFn>>>
|
|
bool queue_job(Worker &w, ProcessFn fn)
|
|
{
|
|
return queue_job(w, std::move(fn), [](bool, std::exception_ptr &) {});
|
|
}
|
|
|
|
inline bool queue_job(Worker &w, std::unique_ptr<JobNew> j)
|
|
{
|
|
return w.push(std::move(j));
|
|
}
|
|
|
|
// Replace the current job queue with a new job. The signature is the same
|
|
// as for queue_job(). This cancels all jobs and
|
|
// will not wait. The new job will begin after the queue cancels properly.
|
|
// Note that this can be called from the UI thread and will not block it if
|
|
// the jobs take longer to cancel.
|
|
template<class...Args> bool replace_job(Worker &w, Args&& ...args)
|
|
{
|
|
w.cancel_all();
|
|
return queue_job(w, std::forward<Args>(args)...);
|
|
}
|
|
|
|
// Cancel the current job and wait for it to actually be stopped.
|
|
inline bool stop_current_job(Worker &w, unsigned timeout_ms = 0)
|
|
{
|
|
w.cancel();
|
|
return w.wait_for_current_job(timeout_ms);
|
|
}
|
|
|
|
// Cancel all pending jobs including current one and wait until the worker
|
|
// becomes idle.
|
|
inline bool stop_queue(Worker &w, unsigned timeout_ms = 0)
|
|
{
|
|
w.cancel_all();
|
|
return w.wait_for_idle(timeout_ms);
|
|
}
|
|
|
|
}} // namespace Slic3r::GUI
|
|
|
|
#endif // WORKER_HPP
|