Slic3r::ScriptAsyncRuntime Class Reference

#include </home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/plugin/PluginManager.hpp>

Collaboration diagram for Slic3r::ScriptAsyncRuntime:

Classes
struct	Impl

Public Member Functions
	~ScriptAsyncRuntime ()
	ScriptAsyncRuntime (const ScriptAsyncRuntime &)=delete
ScriptAsyncRuntime &	operator= (const ScriptAsyncRuntime &)=delete
bool	start (const std::string &plugin_key, const std::string &capability_name, std::shared_ptr< PluginCapabilityInterface > capability, std::function< void(const ScriptCompletion &)> on_done)
void	cancel_plugin (const std::string &plugin_key)
bool	has_active_run (const PluginCapabilityInterface *capability) const
void	shutdown ()
void	reset ()

Static Public Member Functions
static ScriptAsyncRuntime &	instance ()
static pybind11::object	current_loop ()

Private Member Functions
	ScriptAsyncRuntime ()

Private Attributes
std::unique_ptr< Impl >	m_impl

Detailed Description

Constructor & Destructor Documentation

~ScriptAsyncRuntime()

Slic3r::ScriptAsyncRuntime::~ScriptAsyncRuntime

(

)

{ shutdown(); }

References shutdown().

Here is the call graph for this function:

ScriptAsyncRuntime() [1/2]

Slic3r::ScriptAsyncRuntime::ScriptAsyncRuntime ( const ScriptAsyncRuntime & )

delete

References ScriptAsyncRuntime().

Referenced by ScriptAsyncRuntime(), instance(), and operator=().

Here is the call graph for this function:

Here is the caller graph for this function:

ScriptAsyncRuntime() [2/2]

Slic3r::ScriptAsyncRuntime::ScriptAsyncRuntime ( )

private

: m_impl(std::make_unique<Impl>()) {}

References m_impl, and Slic3r::make_unique().

Here is the call graph for this function:

Member Function Documentation

cancel_plugin()

void Slic3r::ScriptAsyncRuntime::cancel_plugin

(

const std::string &

plugin_key

)

{
    std::vector<std::shared_ptr<Impl::Run>> runs;
    {
        std::lock_guard<std::mutex> lock(m_impl->mutex);
        for (const auto& run : m_impl->active)
            if (run->plugin_key == plugin_key)
                runs.push_back(run);
    }
 
    for (const auto& run : runs)
        run->cancel_requested.store(true, std::memory_order_release);
 
    for (const auto& run : runs) {
        // A synchronous invocation has no loop to cancel; skip it so the caller never blocks on
        // the GIL while that invocation is (uninterruptibly) running.
        if (!run->has_loop.load(std::memory_order_acquire))
            continue;
 
        PythonGILState gil;
        if (!gil)
            continue;
 
        pybind11::object loop;
        pybind11::object task;
        {
            std::lock_guard<std::mutex> lock(run->handle_mutex);
            loop = run->loop;
            task = run->task;
        }
        if (!loop || !task)
            continue;
 
        try {
            loop.attr("call_soon_threadsafe")(task.attr("cancel"));
        } catch (const std::exception& ex) {
            BOOST_LOG_TRIVIAL(warning) << "Script async cancel failed for plugin '" << plugin_key << "': " << ex.what();
        }
    }
}

References m_impl.

Referenced by Slic3r::PluginManager::cancel_and_wait_for_capabilities().

Here is the caller graph for this function:

current_loop()

pybind11::object Slic3r::ScriptAsyncRuntime::current_loop ( )

static

{
    if (tl_script_loop == nullptr)
        return pybind11::object();
    return pybind11::reinterpret_borrow<pybind11::object>(pybind11::handle(tl_script_loop));
}

has_active_run()

bool Slic3r::ScriptAsyncRuntime::has_active_run

(

const PluginCapabilityInterface *

capability

)

const

{
    std::lock_guard<std::mutex> lock(m_impl->mutex);
    for (const auto& run : m_impl->active)
        if (run->capability.get() == capability)
            return true;
    return false;
}

References m_impl.

instance()

ScriptAsyncRuntime & Slic3r::ScriptAsyncRuntime::instance ( )

static

{
    static ScriptAsyncRuntime inst;
    return inst;
}

References ScriptAsyncRuntime().

Referenced by Slic3r::PluginManager::cancel_and_wait_for_capabilities(), Slic3r::PluginManager::initialize(), Slic3r::PluginManager::instance(), Slic3r::PluginManager::launch_script_capability(), and Slic3r::PluginManager::shutdown().

Here is the call graph for this function:

Here is the caller graph for this function:

operator=()

ScriptAsyncRuntime & Slic3r::ScriptAsyncRuntime::operator= ( const ScriptAsyncRuntime & )

delete

References ScriptAsyncRuntime().

Here is the call graph for this function:

reset()

void Slic3r::ScriptAsyncRuntime::reset

(

)

{
    shutdown();
 
    std::lock_guard<std::mutex> lock(m_impl->mutex);
    m_impl->stopping = false;
}

References m_impl, and shutdown().

Referenced by Slic3r::PluginManager::initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

shutdown()

void Slic3r::ScriptAsyncRuntime::shutdown

(

)

{
    {
        std::lock_guard<std::mutex> lock(m_impl->mutex);
        m_impl->stopping = true;
    }
 
    std::unique_lock<std::mutex> lock(m_impl->mutex);
    m_impl->cv.wait(lock, [this] { return m_impl->active.empty(); });
}

References m_impl.

Referenced by ~ScriptAsyncRuntime(), reset(), and Slic3r::PluginManager::shutdown().

Here is the caller graph for this function:

start()

bool Slic3r::ScriptAsyncRuntime::start	(	const std::string &	plugin_key,
		const std::string &	capability_name,
		std::shared_ptr< PluginCapabilityInterface >	capability,
		std::function< void(const ScriptCompletion &)>	on_done )

{
    if (!PythonInterpreter::instance().is_initialized())
        return false;
 
    auto run             = std::make_shared<Impl::Run>();
    run->plugin_key      = plugin_key;
    run->capability_name = capability_name;
    run->capability      = std::move(capability);
    run->on_done         = std::move(on_done);
 
    {
        std::lock_guard<std::mutex> lock(m_impl->mutex);
        if (m_impl->stopping)
            return false;
        m_impl->active.push_back(run);
    }
 
    // One worker thread per invocation. A stalled invocation of one plugin can never delay another
    // plugin's unload or another invocation, and no invocation body ever runs on the caller (UI)
    // thread. The thread holds `run` (and so the capability) until it finishes; the runtime tracks
    // it in `active` and waits for it on shutdown.
    Impl* impl = m_impl.get();
    try {
        std::thread([impl, run] { impl->run_invocation(run); }).detach();
    } catch (...) {
        std::lock_guard<std::mutex> lock(m_impl->mutex);
        m_impl->active.erase(std::remove(m_impl->active.begin(), m_impl->active.end(), run), m_impl->active.end());
        return false;
    }
    return true;
}

References Slic3r::PythonInterpreter::instance(), and m_impl.

Referenced by Slic3r::PluginManager::launch_script_capability().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

m_impl

std::unique_ptr<Impl> Slic3r::ScriptAsyncRuntime::m_impl

private

Referenced by ScriptAsyncRuntime(), cancel_plugin(), has_active_run(), reset(), shutdown(), and start().

---

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

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