Slic3r::ScriptAsyncRuntime::Impl Struct Reference

Collaboration diagram for Slic3r::ScriptAsyncRuntime::Impl:

Classes
struct	Run

Public Member Functions
void	run_invocation (const std::shared_ptr< Run > &run)

Public Attributes
std::mutex	mutex
std::condition_variable	cv
std::vector< std::shared_ptr< Run > >	active
bool	stopping = false

Detailed Description

---

Class Documentation

Slic3r::ScriptAsyncRuntime::Impl::Run

struct Slic3r::ScriptAsyncRuntime::Impl::Run

Collaboration diagram for Slic3r::ScriptAsyncRuntime::Impl::Run:

Class Members
atomic< bool >	cancel_requested {false}
shared_ptr< PluginCapabilityInterface >	capability
string	capability_name
mutex	handle_mutex
atomic< bool >	has_loop {false}
object	loop
function< void(const ScriptCompletion &)>	on_done
string	plugin_key
object	task

Member Function Documentation

run_invocation()

void Slic3r::ScriptAsyncRuntime::Impl::run_invocation

(

const std::shared_ptr< Run > &

run

)

{
    ScriptCompletion completion;
 
    {
        PythonRuntimeLease lease = PythonInterpreter::instance().acquire_runtime_lease();
        if (!lease) {
            completion.error = _u8L("Python interpreter is shutting down.");
        } else {
            pybind11::gil_scoped_acquire gil;
 
            if (run->cancel_requested.load(std::memory_order_acquire)) {
                // Cancelled before it ran: expected termination, never an error.
                completion.cancelled = true;
            } else {
                // Hold the capability reference, the audit scope and the GIL for the whole
                // invocation, so unload/shutdown cannot tear the module out from under it.
                PluginCapabilityInterface::RefCounter ref_counter(*run->capability);
 
                std::optional<ScopedPluginAuditContext> audit_scope;
                if (!run->capability->audit_plugin_key().empty())
                    audit_scope.emplace(run->capability->audit_plugin_key(), run->capability->name());
 
                // Detection and execution both happen here, on the worker: a synchronous
                // `def execute` runs to completion off the UI thread, exactly like an `async def`.
                ScriptExecuteInvocation invocation = invoke_script_execute(run->capability);
                if (!invocation.error.empty()) {
                    completion.error = invocation.error;
                } else if (!invocation.is_async) {
                    completion.result = invocation.result;
                } else if (run->cancel_requested.load(std::memory_order_acquire)) {
                    completion.cancelled = true;
                } else {
                    try {
                        pybind11::module_ asyncio = pybind11::module_::import("asyncio");
                        pybind11::object  loop    = asyncio.attr("new_event_loop")();
                        asyncio.attr("set_event_loop")(loop);
 
                        tl_script_loop = loop.ptr();
                        Py_INCREF(tl_script_loop);
 
                        pybind11::object task = loop.attr("create_task")(std::move(invocation.awaitable));
                        {
                            std::lock_guard<std::mutex> lock(run->handle_mutex);
                            run->loop = loop;
                            run->task = task;
                        }
                        run->has_loop.store(true, std::memory_order_release);
                        // A cancellation that arrived before the loop came up must still land.
                        if (run->cancel_requested.load(std::memory_order_acquire))
                            loop.attr("call_soon_threadsafe")(task.attr("cancel"));
 
                        try {
                            pybind11::object returned = loop.attr("run_until_complete")(task);
                            completion.result = returned.cast<ExecutionResult>();
                        } catch (pybind11::error_already_set& err) {
                            // Only our own cancel_plugin() cancellation is expected termination; a
                            // CancelledError the plugin raised on its own stays a real error.
                            if (err.matches(asyncio.attr("CancelledError")) &&
                                run->cancel_requested.load(std::memory_order_acquire)) {
                                completion.cancelled = true;
                            } else {
                                log_python_exception_keep(err);
                                completion.error = err.what();
                            }
                        }
 
                        run->has_loop.store(false, std::memory_order_release);
                        {
                            std::lock_guard<std::mutex> lock(run->handle_mutex);
                            run->task = pybind11::object();
                            run->loop = pybind11::object();
                        }
                        Py_CLEAR(tl_script_loop);
                        loop.attr("close")();
                        asyncio.attr("set_event_loop")(pybind11::none());
                    } catch (pybind11::error_already_set& err) {
                        log_python_exception_keep(err);
                        completion.error = err.what();
                    } catch (const std::exception& ex) {
                        completion.error = ex.what();
                    }
 
                    // Covers an exception thrown after the loop came up but before the clear above.
                    if (run->has_loop.load(std::memory_order_acquire)) {
                        run->has_loop.store(false, std::memory_order_release);
                        std::lock_guard<std::mutex> lock(run->handle_mutex);
                        run->task = pybind11::object();
                        run->loop = pybind11::object();
                    }
 
                    if (tl_script_loop != nullptr)
                        Py_CLEAR(tl_script_loop);
                }
            }
 
            // Drop the capability reference while the GIL is held: releasing a pybind holder from
            // a non-Python thread would DECREF the capability without the GIL. Runs on every
            // lease-valid path, including an invocation cancelled before it ran.
            run->capability.reset();
        }
    }
 
    // A cancellation requested by cancel_plugin() (unload/shutdown) is expected termination and is
    // authoritative: whatever the body did — finished, swallowed CancelledError, or failed — nothing
    // is surfaced as an error or as a normal success.
    if (run->cancel_requested.load(std::memory_order_acquire)) {
        completion.cancelled = true;
        completion.error.clear();
    }
 
    auto on_done = std::move(run->on_done);
    auto deliver = [on_done, completion]() {
        if (on_done)
            on_done(completion);
    };
 
    if (wxTheApp == nullptr || wxIsMainThread())
        deliver();
    else
        GUI::wxGetApp().CallAfter(deliver);
 
    // Leave `active` last, so a drain cannot observe the run as finished before its completion was
    // queued/delivered and its capability reference released.
    {
        std::lock_guard<std::mutex> lock(mutex);
        active.erase(std::remove(active.begin(), active.end(), run), active.end());
    }
    cv.notify_all();
}

References _u8L, Slic3r::PythonInterpreter::acquire_runtime_lease(), active, Slic3r::ScriptExecuteInvocation::awaitable, Slic3r::ScriptCompletion::cancelled, Slic3r::ScriptCompletion::error, Slic3r::ScriptExecuteInvocation::error, Slic3r::PythonInterpreter::instance(), Slic3r::invoke_script_execute(), Slic3r::ScriptExecuteInvocation::is_async, Slic3r::log_python_exception_keep(), mutex, Slic3r::ScriptCompletion::result, and Slic3r::ScriptExecuteInvocation::result.

Here is the call graph for this function:

Member Data Documentation

active

std::vector<std::shared_ptr<Run> > Slic3r::ScriptAsyncRuntime::Impl::active

Referenced by run_invocation().

cv

std::condition_variable Slic3r::ScriptAsyncRuntime::Impl::cv

mutex

std::mutex Slic3r::ScriptAsyncRuntime::Impl::mutex

Referenced by run_invocation().

stopping

bool Slic3r::ScriptAsyncRuntime::Impl::stopping = false

---

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

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/plugin/PluginManager.cpp