lune-org/mlua-luau-scheduler
1
0
Fork 0
mirror of https://github.com/lune-org/mlua-luau-scheduler.git synced 2025-04-03 01:50:57 +01:00
Code Issues Projects Releases Packages Wiki Activity

Last rename, I swear

Browse source
This commit is contained in:
Filip Tibell 2024-02-11 10:47:39 +01:00
parent 2b75b461fe
commit 8e8647e061
No known key found for this signature in database
16 changed files with 141 additions and 143 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
Cargo.lock generated
View file

@ -370,7 +370,7 @@ dependencies = [
]
[[package]]
name = "mlua-luau-runtime"
name = "mlua-luau-scheduler"
version = "0.0.0"
dependencies = [
"async-executor",

8
Cargo.toml
View file

@ -1,12 +1,12 @@
[package]
name = "mlua-luau-runtime"
name = "mlua-luau-scheduler"
version = "0.0.0"
edition = "2021"
license = "MPL-2.0"
repository = "https://github.com/lune-org/mlua-luau-runtime"
description = "Luau-based async runtime, using mlua and async-executor"
repository = "https://github.com/lune-org/mlua-luau-scheduler"
description = "Luau-based async scheduler, using mlua and async-executor"
readme = "README.md"
keywords = ["async", "luau", "runtime"]
keywords = ["async", "luau", "scheduler"]
categories = ["async"]
[dependencies]

20
README.md
View file

@ -1,22 +1,22 @@
<!-- markdownlint-disable MD033 -->
<!-- markdownlint-disable MD041 -->
<h1 align="center">mlua-luau-runtime</h1>
<h1 align="center">mlua-luau-scheduler</h1>
<div align="center">
<div>
<a href="https://github.com/lune-org/mlua-luau-runtime/actions">
<img src="https://shields.io/endpoint?url=https://badges.readysetplay.io/workflow/lune-org/mlua-luau-runtime/ci.yaml" alt="CI status" />
<a href="https://github.com/lune-org/mlua-luau-scheduler/actions">
<img src="https://shields.io/endpoint?url=https://badges.readysetplay.io/workflow/lune-org/mlua-luau-scheduler/ci.yaml" alt="CI status" />
</a>
<a href="https://github.com/lune-org/mlua-luau-runtime/blob/main/LICENSE.txt">
<img src="https://img.shields.io/github/license/lune-org/mlua-luau-runtime.svg?label=License&color=informational" alt="Crate license" />
<a href="https://github.com/lune-org/mlua-luau-scheduler/blob/main/LICENSE.txt">
<img src="https://img.shields.io/github/license/lune-org/mlua-luau-scheduler.svg?label=License&color=informational" alt="Crate license" />
</a>
</div>
</div>
<br/>
An async runtime for Luau, using [`mlua`][mlua] and built on top of [`async-executor`][async-executor].
An async scheduler for Luau, using [`mlua`][mlua] and built on top of [`async-executor`][async-executor].
This crate is runtime-agnostic and is compatible with any async runtime, including [Tokio][tokio], [smol][smol], [async-std][async-std], and others. </br>
However, since many dependencies are shared with [smol][smol], depending on it over other runtimes may be preferred.
@ -39,7 +39,7 @@ use async_io::{block_on, Timer};
use async_fs::read_to_string;
use mlua::prelude::*;
use mlua_luau_runtime::*;
use mlua_luau_scheduler::*;
```
### 2. Set up Lua environment
@ -73,16 +73,16 @@ lua.globals().set(
)?;
```
### 3. Set up runtime, run threads
### 3. Set up scheduler, run threads
```rs
let rt = Runtime::new(&lua)?;
let rt = Scheduler::new(&lua)?;
// We can create multiple lua threads ...
let sleepThread = lua.load("sleep(0.1)");
let fileThread = lua.load("readFile(\"Cargo.toml\")");
// ... spawn them both onto the runtime ...
// ... spawn them both onto the scheduler ...
rt.push_thread_front(sleepThread, ());
rt.push_thread_front(fileThread, ());

6
examples/basic_sleep.rs
View file

@ -5,7 +5,7 @@ use std::time::{Duration, Instant};
use async_io::{block_on, Timer};
use mlua::prelude::*;
use mlua_luau_runtime::Runtime;
use mlua_luau_scheduler::Scheduler;
const MAIN_SCRIPT: &str = include_str!("./lua/basic_sleep.luau");
@ -27,8 +27,8 @@ pub fn main() -> LuaResult<()> {
})?,
)?;
// Load the main script into a runtime
let rt = Runtime::new(&lua);
// Load the main script into a scheduler
let rt = Scheduler::new(&lua);
let main = lua.load(MAIN_SCRIPT);
rt.push_thread_front(main, ())?;

6
examples/basic_spawn.rs
View file

@ -6,7 +6,7 @@ use async_fs::read_to_string;
use async_io::block_on;
use mlua::prelude::*;
use mlua_luau_runtime::{LuaSpawnExt, Runtime};
use mlua_luau_scheduler::{LuaSpawnExt, Scheduler};
const MAIN_SCRIPT: &str = include_str!("./lua/basic_spawn.luau");
@ -46,8 +46,8 @@ pub fn main() -> LuaResult<()> {
})?,
)?;
// Load the main script into a runtime
let rt = Runtime::new(&lua);
// Load the main script into a scheduler
let rt = Scheduler::new(&lua);
let main = lua.load(MAIN_SCRIPT);
rt.push_thread_front(main, ())?;

8
examples/callbacks.rs
View file

@ -2,7 +2,7 @@
#![allow(clippy::missing_panics_doc)]
use mlua::prelude::*;
use mlua_luau_runtime::Runtime;
use mlua_luau_scheduler::Scheduler;
use async_io::block_on;
@ -18,8 +18,8 @@ pub fn main() -> LuaResult<()> {
// Set up persistent Lua environment
let lua = Lua::new();
// Create a new runtime with custom callbacks
let rt = Runtime::new(&lua);
// Create a new scheduler with custom callbacks
let rt = Scheduler::new(&lua);
rt.set_error_callback(|e| {
println!(
"Captured error from Lua!\n{}\n{e}\n{}",
@ -28,7 +28,7 @@ pub fn main() -> LuaResult<()> {
);
});
// Load the main script into the runtime, and keep track of the thread we spawn
// Load the main script into the scheduler, and keep track of the thread we spawn
let main = lua.load(MAIN_SCRIPT);
let id = rt.push_thread_front(main, ())?;

6
examples/exit_code.rs
View file

@ -4,7 +4,7 @@
use async_io::block_on;
use mlua::prelude::*;
use mlua_luau_runtime::{Functions, Runtime};
use mlua_luau_scheduler::{Functions, Scheduler};
const MAIN_SCRIPT: &str = include_str!("./lua/exit_code.luau");
@ -17,12 +17,12 @@ pub fn main() -> LuaResult<()> {
// Set up persistent Lua environment
let lua = Lua::new();
let rt = Runtime::new(&lua);
let rt = Scheduler::new(&lua);
let fns = Functions::new(&lua)?;
lua.globals().set("exit", fns.exit)?;
// Load the main script into the runtime
// Load the main script into the scheduler
let main = lua.load(MAIN_SCRIPT);
rt.push_thread_front(main, ())?;

6
examples/lots_of_threads.rs
View file

@ -5,7 +5,7 @@ use std::time::Duration;
use async_io::{block_on, Timer};
use mlua::prelude::*;
use mlua_luau_runtime::{Functions, Runtime};
use mlua_luau_scheduler::{Functions, Scheduler};
const MAIN_SCRIPT: &str = include_str!("./lua/lots_of_threads.luau");
@ -20,7 +20,7 @@ pub fn main() -> LuaResult<()> {
// Set up persistent Lua environment
let lua = Lua::new();
let rt = Runtime::new(&lua);
let rt = Scheduler::new(&lua);
let fns = Functions::new(&lua)?;
lua.globals().set("spawn", fns.spawn)?;
@ -34,7 +34,7 @@ pub fn main() -> LuaResult<()> {
})?,
)?;
// Load the main script into the runtime
// Load the main script into the scheduler
let main = lua.load(MAIN_SCRIPT);
rt.push_thread_front(main, ())?;

6
examples/scheduler_ordering.rs
View file

@ -6,7 +6,7 @@ use std::time::{Duration, Instant};
use async_io::{block_on, Timer};
use mlua::prelude::*;
use mlua_luau_runtime::{Functions, Runtime};
use mlua_luau_scheduler::{Functions, Scheduler};
const MAIN_SCRIPT: &str = include_str!("./lua/scheduler_ordering.luau");
@ -19,7 +19,7 @@ pub fn main() -> LuaResult<()> {
// Set up persistent Lua environment
let lua = Lua::new();
let rt = Runtime::new(&lua);
let rt = Scheduler::new(&lua);
let fns = Functions::new(&lua)?;
lua.globals().set("spawn", fns.spawn)?;
@ -34,7 +34,7 @@ pub fn main() -> LuaResult<()> {
})?,
)?;
// Load the main script into the runtime, and keep track of the thread we spawn
// Load the main script into the scheduler, and keep track of the thread we spawn
let main = lua.load(MAIN_SCRIPT);
let id = rt.push_thread_front(main, ())?;

6
examples/tracy.rs
View file

@ -21,7 +21,7 @@ use tracing_subscriber::layer::SubscriberExt;
use tracing_tracy::{client::Client as TracyClient, TracyLayer};
use mlua::prelude::*;
use mlua_luau_runtime::{Functions, Runtime};
use mlua_luau_scheduler::{Functions, Scheduler};
const MAIN_SCRIPT: &str = include_str!("./lua/lots_of_threads.luau");
@ -35,7 +35,7 @@ pub fn main() -> LuaResult<()> {
// Set up persistent Lua environment
let lua = Lua::new();
let rt = Runtime::new(&lua);
let rt = Scheduler::new(&lua);
let fns = Functions::new(&lua)?;
lua.globals().set("spawn", fns.spawn)?;
@ -49,7 +49,7 @@ pub fn main() -> LuaResult<()> {
})?,
)?;
// Load the main script into the runtime
// Load the main script into the scheduler
let main = lua.load(MAIN_SCRIPT);
rt.push_thread_front(main, ())?;

32
lib/functions.rs
View file

@ -9,16 +9,16 @@ use crate::{
error_callback::ThreadErrorCallback,
queue::{DeferredThreadQueue, SpawnedThreadQueue},
result_map::ThreadResultMap,
runtime::Runtime,
scheduler::Scheduler,
thread_id::ThreadId,
traits::LuaRuntimeExt,
traits::LuaSchedulerExt,
util::{is_poll_pending, LuaThreadOrFunction, ThreadResult},
};
const ERR_METADATA_NOT_ATTACHED: &str = "\
Lua state does not have runtime metadata attached!\
\nThis is most likely caused by creating functions outside of a runtime.\
\nRuntime functions must always be created from within an active runtime.\
Lua state does not have scheduler metadata attached!\
\nThis is most likely caused by creating functions outside of a scheduler.\
\nScheduler functions must always be created from within an active scheduler.\
";
const EXIT_IMPL_LUA: &str = r"
@ -39,29 +39,29 @@ end
";
/**
A collection of lua functions that may be called to interact with a [`Runtime`].
A collection of lua functions that may be called to interact with a [`Scheduler`].
*/
pub struct Functions<'lua> {
/**
Implementation of `coroutine.resume` that handles async polling properly.
Defers onto the runtime queue if the thread calls an async function.
Defers onto the scheduler queue if the thread calls an async function.
*/
pub resume: LuaFunction<'lua>,
/**
Implementation of `coroutine.wrap` that handles async polling properly.
Defers onto the runtime queue if the thread calls an async function.
Defers onto the scheduler queue if the thread calls an async function.
*/
pub wrap: LuaFunction<'lua>,
/**
Resumes a function / thread once instantly, and runs until first yield.
Spawns onto the runtime queue if not completed.
Spawns onto the scheduler queue if not completed.
*/
pub spawn: LuaFunction<'lua>,
/**
Defers a function / thread onto the runtime queue.
Defers a function / thread onto the scheduler queue.
Does not resume instantly, only adds to the queue.
*/
@ -71,7 +71,7 @@ pub struct Functions<'lua> {
*/
pub cancel: LuaFunction<'lua>,
/**
Exits the runtime, stopping all other threads and closing the runtime.
Exits the scheduler, stopping all other threads and closing the scheduler.
Yields the calling thread to ensure that it does not continue.
*/
@ -80,7 +80,7 @@ pub struct Functions<'lua> {
impl<'lua> Functions<'lua> {
/**
Creates a new collection of Lua functions that may be called to interact with a [`Runtime`].
Creates a new collection of Lua functions that may be called to interact with a [`Scheduler`].
# Errors
@ -88,7 +88,7 @@ impl<'lua> Functions<'lua> {
# Panics
Panics when the given [`Lua`] instance does not have an attached [`Runtime`].
Panics when the given [`Lua`] instance does not have an attached [`Scheduler`].
*/
pub fn new(lua: &'lua Lua) -> LuaResult<Self> {
let spawn_queue = lua
@ -157,7 +157,7 @@ impl<'lua> Functions<'lua> {
])?;
let wrap = lua
.load(WRAP_IMPL_LUA)
.set_name("=__runtime_wrap")
.set_name("=__scheduler_wrap")
.set_environment(wrap_env)
.into_function()?;
@ -243,7 +243,7 @@ impl<'lua> Functions<'lua> {
])?;
let exit = lua
.load(EXIT_IMPL_LUA)
.set_name("=__runtime_exit")
.set_name("=__scheduler_exit")
.set_environment(exit_env)
.into_function()?;
@ -260,7 +260,7 @@ impl<'lua> Functions<'lua> {
impl Functions<'_> {
/**
Injects [`Runtime`]-compatible functions into the given [`Lua`] instance.
Injects [`Scheduler`]-compatible functions into the given [`Lua`] instance.
This will overwrite the following functions:

6
lib/lib.rs
View file

@ -3,14 +3,14 @@ mod exit;
mod functions;
mod queue;
mod result_map;
mod runtime;
mod scheduler;
mod status;
mod thread_id;
mod traits;
mod util;
pub use functions::Functions;
pub use runtime::Runtime;
pub use scheduler::Scheduler;
pub use status::Status;
pub use thread_id::ThreadId;
pub use traits::{IntoLuaThread, LuaRuntimeExt, LuaSpawnExt};
pub use traits::{IntoLuaThread, LuaSchedulerExt, LuaSpawnExt};

80
lib/runtime.rs → lib/scheduler.rs
View file

@ -26,25 +26,25 @@ use crate::{
};
const ERR_METADATA_ALREADY_ATTACHED: &str = "\
Lua state already has runtime metadata attached!\
\nThis may be caused by running multiple runtimes on the same Lua state, or a call to Runtime::run being cancelled.\
\nOnly one runtime can be used per Lua state at once, and runtimes must always run until completion.\
Lua state already has scheduler metadata attached!\
\nThis may be caused by running multiple schedulers on the same Lua state, or a call to Scheduler::run being cancelled.\
\nOnly one scheduler can be used per Lua state at once, and schedulers must always run until completion.\
";
const ERR_METADATA_REMOVED: &str = "\
Lua state runtime metadata was unexpectedly removed!\
\nThis should never happen, and is likely a bug in the runtime.\
Lua state scheduler metadata was unexpectedly removed!\
\nThis should never happen, and is likely a bug in the scheduler.\
";
const ERR_SET_CALLBACK_WHEN_RUNNING: &str = "\
Cannot set error callback when runtime is running!\
Cannot set error callback when scheduler is running!\
";
/**
A runtime for running Lua threads and async tasks.
A scheduler for running Lua threads and async tasks.
*/
#[derive(Clone)]
pub struct Runtime<'lua> {
pub struct Scheduler<'lua> {
lua: &'lua Lua,
queue_spawn: SpawnedThreadQueue,
queue_defer: DeferredThreadQueue,
@ -54,18 +54,18 @@ pub struct Runtime<'lua> {
exit: Exit,
}
impl<'lua> Runtime<'lua> {
impl<'lua> Scheduler<'lua> {
/**
Creates a new runtime for the given Lua state.
Creates a new scheduler for the given Lua state.
This runtime will have a default error callback that prints errors to stderr.
This scheduler will have a default error callback that prints errors to stderr.
# Panics
Panics if the given Lua state already has a runtime attached to it.
Panics if the given Lua state already has a scheduler attached to it.
*/
#[must_use]
pub fn new(lua: &'lua Lua) -> Runtime<'lua> {
pub fn new(lua: &'lua Lua) -> Scheduler<'lua> {
let queue_spawn = SpawnedThreadQueue::new();
let queue_defer = DeferredThreadQueue::new();
let error_callback = ThreadErrorCallback::default();
@ -101,7 +101,7 @@ impl<'lua> Runtime<'lua> {
let status = Rc::new(Cell::new(Status::NotStarted));
Runtime {
Scheduler {
lua,
queue_spawn,
queue_defer,
@ -113,7 +113,7 @@ impl<'lua> Runtime<'lua> {
}
/**
Sets the current status of this runtime and emits relevant tracing events.
Sets the current status of this scheduler and emits relevant tracing events.
*/
fn set_status(&self, status: Status) {
debug!(status = ?status, "status");
@ -121,7 +121,7 @@ impl<'lua> Runtime<'lua> {
}
/**
Returns the current status of this runtime.
Returns the current status of this scheduler.
*/
#[must_use]
pub fn status(&self) -> Status {
@ -129,7 +129,7 @@ impl<'lua> Runtime<'lua> {
}
/**
Sets the error callback for this runtime.
Sets the error callback for this scheduler.
This callback will be called whenever a Lua thread errors.
@ -137,7 +137,7 @@ impl<'lua> Runtime<'lua> {
# Panics
Panics if the runtime is currently running.
Panics if the scheduler is currently running.
*/
pub fn set_error_callback(&self, callback: impl Fn(LuaError) + Send + 'static) {
assert!(
@ -148,13 +148,13 @@ impl<'lua> Runtime<'lua> {
}
/**
Clears the error callback for this runtime.
Clears the error callback for this scheduler.
This will remove any current error callback, including default(s).
# Panics
Panics if the runtime is currently running.
Panics if the scheduler is currently running.
*/
pub fn remove_error_callback(&self) {
assert!(
@ -165,7 +165,7 @@ impl<'lua> Runtime<'lua> {
}
/**
Gets the exit code for this runtime, if one has been set.
Gets the exit code for this scheduler, if one has been set.
*/
#[must_use]
pub fn get_exit_code(&self) -> Option<ExitCode> {
@ -173,16 +173,16 @@ impl<'lua> Runtime<'lua> {
}
/**
Sets the exit code for this runtime.
Sets the exit code for this scheduler.
This will cause [`Runtime::run`] to exit immediately.
This will cause [`Scheduler::run`] to exit immediately.
*/
pub fn set_exit_code(&self, code: ExitCode) {
self.exit.set(code);
}
/**
Spawns a chunk / function / thread onto the runtime queue.
Spawns a chunk / function / thread onto the scheduler queue.
Threads are guaranteed to be resumed in the order that they were pushed to the queue.
@ -190,7 +190,7 @@ impl<'lua> Runtime<'lua> {
Returns a [`ThreadId`] that can be used to retrieve the result of the thread.
Note that the result may not be available until [`Runtime::run`] completes.
Note that the result may not be available until [`Scheduler::run`] completes.
# Errors
@ -207,7 +207,7 @@ impl<'lua> Runtime<'lua> {
}
/**
Defers a chunk / function / thread onto the runtime queue.
Defers a chunk / function / thread onto the scheduler queue.
Deferred threads are guaranteed to run after all spawned threads either yield or complete.
@ -217,7 +217,7 @@ impl<'lua> Runtime<'lua> {
Returns a [`ThreadId`] that can be used to retrieve the result of the thread.
Note that the result may not be available until [`Runtime::run`] completes.
Note that the result may not be available until [`Scheduler::run`] completes.
# Errors
@ -236,13 +236,13 @@ impl<'lua> Runtime<'lua> {
/**
Gets the tracked result for the [`LuaThread`] with the given [`ThreadId`].
Depending on the current [`Runtime::status`], this method will return:
Depending on the current [`Scheduler::status`], this method will return:
- [`Status::NotStarted`]: returns `None`.
- [`Status::Running`]: may return `Some(Ok(v))` or `Some(Err(e))`, but it is not guaranteed.
- [`Status::Completed`]: returns `Some(Ok(v))` or `Some(Err(e))`.
Note that this method also takes the value out of the runtime and
Note that this method also takes the value out of the scheduler and
stops tracking the given thread, so it may only be called once.
Any subsequent calls after this method returns `Some` will return `None`.
@ -262,17 +262,17 @@ impl<'lua> Runtime<'lua> {
}
/**
Runs the runtime until all Lua threads have completed.
Runs the scheduler until all Lua threads have completed.
Note that the given Lua state must be the same one that was
used to create this runtime, otherwise this method will panic.
used to create this scheduler, otherwise this method will panic.
# Panics
Panics if the given Lua state already has a runtime attached to it.
Panics if the given Lua state already has a scheduler attached to it.
*/
#[allow(clippy::too_many_lines)]
#[instrument(level = "debug", name = "runtime::run", skip(self))]
#[instrument(level = "debug", name = "Scheduler::run", skip(self))]
pub async fn run(&self) {
/*
Create new executors to use - note that we do not need create multiple executors
@ -290,10 +290,10 @@ impl<'lua> Runtime<'lua> {
let fut_queue = Rc::new(FuturesQueue::new());
/*
Store the main executor and queue in Lua, so that they may be used with LuaRuntimeExt.
Store the main executor and queue in Lua, so that they may be used with LuaSchedulerExt.
Also ensure we do not already have an executor or queues - these are definite user errors
and may happen if the user tries to run multiple runtimes on the same Lua state at once.
and may happen if the user tries to run multiple schedulers on the same Lua state at once.
*/
assert!(
self.lua.app_data_ref::<WeakArc<Executor>>().is_none(),
@ -369,7 +369,7 @@ impl<'lua> Runtime<'lua> {
// 5
let mut num_processed = 0;
let span_tick = trace_span!("runtime::tick");
let span_tick = trace_span!("scheduler::tick");
let fut_tick = async {
local_exec.tick().await;
// NOTE: Try to do as much work as possible instead of just a single tick()
@ -398,21 +398,21 @@ impl<'lua> Runtime<'lua> {
let mut num_deferred = 0;
let mut num_futures = 0;
{
let _span = trace_span!("runtime::drain_spawned").entered();
let _span = trace_span!("scheduler::drain_spawned").entered();
for (thread, args) in self.queue_spawn.drain_items(self.lua) {
process_thread(thread, args);
num_spawned += 1;
}
}
{
let _span = trace_span!("runtime::drain_deferred").entered();
let _span = trace_span!("scheduler::drain_deferred").entered();
for (thread, args) in self.queue_defer.drain_items(self.lua) {
process_thread(thread, args);
num_deferred += 1;
}
}
{
let _span = trace_span!("runtime::drain_futures").entered();
let _span = trace_span!("scheduler::drain_futures").entered();
for fut in fut_queue.drain_items() {
local_exec.spawn(fut).detach();
num_futures += 1;
@ -452,7 +452,7 @@ impl<'lua> Runtime<'lua> {
}
}
impl Drop for Runtime<'_> {
impl Drop for Scheduler<'_> {
fn drop(&mut self) {
if panicking() {
// Do not cause further panics if already panicking, as

8
lib/status.rs
View file

@ -1,15 +1,15 @@
#![allow(clippy::module_name_repetitions)]
/**
The current status of a runtime.
The current status of a scheduler.
*/
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum Status {
/// The runtime has not yet started running.
/// The scheduler has not yet started running.
NotStarted,
/// The runtime is currently running.
/// The scheduler is currently running.
Running,
/// The runtime has completed.
/// The scheduler has completed.
Completed,
}

82
lib/traits.rs
View file

@ -13,13 +13,13 @@ use crate::{
exit::Exit,
queue::{DeferredThreadQueue, FuturesQueue, SpawnedThreadQueue},
result_map::ThreadResultMap,
runtime::Runtime,
scheduler::Scheduler,
thread_id::ThreadId,
};
/**
Trait for any struct that can be turned into an [`LuaThread`]
and passed to the runtime, implemented for the following types:
and passed to the scheduler, implemented for the following types:
- Lua threads ([`LuaThread`])
- Lua functions ([`LuaFunction`])
@ -64,34 +64,34 @@ where
}
/**
Trait for interacting with the current [`Runtime`].
Trait for interacting with the current [`Scheduler`].
Provides extra methods on the [`Lua`] struct for:
- Setting the exit code and forcibly stopping the runtime
- Setting the exit code and forcibly stopping the scheduler
- Pushing (spawning) and deferring (pushing to the back) lua threads
- Tracking and getting the result of lua threads
*/
pub trait LuaRuntimeExt<'lua> {
pub trait LuaSchedulerExt<'lua> {
/**
Sets the exit code of the current runtime.
Sets the exit code of the current scheduler.
See [`Runtime::set_exit_code`] for more information.
See [`Scheduler::set_exit_code`] for more information.
# Panics
Panics if called outside of a running [`Runtime`].
Panics if called outside of a running [`Scheduler`].
*/
fn set_exit_code(&self, code: ExitCode);
/**
Pushes (spawns) a lua thread to the **front** of the current runtime.
Pushes (spawns) a lua thread to the **front** of the current scheduler.
See [`Runtime::push_thread_front`] for more information.
See [`Scheduler::push_thread_front`] for more information.
# Panics
Panics if called outside of a running [`Runtime`].
Panics if called outside of a running [`Scheduler`].
*/
fn push_thread_front(
&'lua self,
@ -100,13 +100,13 @@ pub trait LuaRuntimeExt<'lua> {
) -> LuaResult<ThreadId>;
/**
Pushes (defers) a lua thread to the **back** of the current runtime.
Pushes (defers) a lua thread to the **back** of the current scheduler.
See [`Runtime::push_thread_back`] for more information.
See [`Scheduler::push_thread_back`] for more information.
# Panics
Panics if called outside of a running [`Runtime`].
Panics if called outside of a running [`Scheduler`].
*/
fn push_thread_back(
&'lua self,
@ -115,7 +115,7 @@ pub trait LuaRuntimeExt<'lua> {
) -> LuaResult<ThreadId>;
/**
Registers the given thread to be tracked within the current runtime.
Registers the given thread to be tracked within the current scheduler.
Must be called before waiting for a thread to complete or getting its result.
*/
@ -124,28 +124,28 @@ pub trait LuaRuntimeExt<'lua> {
/**
Gets the result of the given thread.
See [`Runtime::get_thread_result`] for more information.
See [`Scheduler::get_thread_result`] for more information.
# Panics
Panics if called outside of a running [`Runtime`].
Panics if called outside of a running [`Scheduler`].
*/
fn get_thread_result(&'lua self, id: ThreadId) -> Option<LuaResult<LuaMultiValue<'lua>>>;
/**
Waits for the given thread to complete.
See [`Runtime::wait_for_thread`] for more information.
See [`Scheduler::wait_for_thread`] for more information.
# Panics
Panics if called outside of a running [`Runtime`].
Panics if called outside of a running [`Scheduler`].
*/
fn wait_for_thread(&'lua self, id: ThreadId) -> impl Future<Output = ()>;
}
/**
Trait for interacting with the [`Executor`] for the current [`Runtime`].
Trait for interacting with the [`Executor`] for the current [`Scheduler`].
Provides extra methods on the [`Lua`] struct for:
@ -159,7 +159,7 @@ pub trait LuaSpawnExt<'lua> {
# Panics
Panics if called outside of a running [`Runtime`].
Panics if called outside of a running [`Scheduler`].
# Example usage
@ -167,7 +167,7 @@ pub trait LuaSpawnExt<'lua> {
use async_io::block_on;
use mlua::prelude::*;
use mlua_luau_runtime::*;
use mlua_luau_scheduler::*;
fn main() -> LuaResult<()> {
let lua = Lua::new();
@ -182,15 +182,13 @@ pub trait LuaSpawnExt<'lua> {
})?
)?;
let rt = Runtime::new(&lua);
let rt = Scheduler::new(&lua);
rt.push_thread_front(lua.load("spawnBackgroundTask()"), ());
block_on(rt.run());
Ok(())
}
```
[`Runtime`]: crate::Runtime
*/
fn spawn<F, T>(&self, fut: F) -> Task<T>
where
@ -201,11 +199,11 @@ pub trait LuaSpawnExt<'lua> {
Spawns the given thread-local future on the current executor.
Note that this future will run detached and always to completion,
preventing the [`Runtime`] was spawned on from completing until done.
preventing the [`Scheduler`] was spawned on from completing until done.
# Panics
Panics if called outside of a running [`Runtime`].
Panics if called outside of a running [`Scheduler`].
# Example usage
@ -213,7 +211,7 @@ pub trait LuaSpawnExt<'lua> {
use async_io::block_on;
use mlua::prelude::*;
use mlua_luau_runtime::*;
use mlua_luau_scheduler::*;
fn main() -> LuaResult<()> {
let lua = Lua::new();
@ -228,7 +226,7 @@ pub trait LuaSpawnExt<'lua> {
})?
)?;
let rt = Runtime::new(&lua);
let rt = Scheduler::new(&lua);
rt.push_thread_front(lua.load("spawnLocalTask()"), ());
block_on(rt.run());
@ -247,7 +245,7 @@ pub trait LuaSpawnExt<'lua> {
# Panics
Panics if called outside of a running [`Runtime`].
Panics if called outside of a running [`Scheduler`].
# Example usage
@ -255,7 +253,7 @@ pub trait LuaSpawnExt<'lua> {
use async_io::block_on;
use mlua::prelude::*;
use mlua_luau_runtime::*;
use mlua_luau_scheduler::*;
fn main() -> LuaResult<()> {
let lua = Lua::new();
@ -270,7 +268,7 @@ pub trait LuaSpawnExt<'lua> {
})?
)?;
let rt = Runtime::new(&lua);
let rt = Scheduler::new(&lua);
rt.push_thread_front(lua.load("spawnBlockingTask()"), ());
block_on(rt.run());
@ -284,11 +282,11 @@ pub trait LuaSpawnExt<'lua> {
T: Send + 'static;
}
impl<'lua> LuaRuntimeExt<'lua> for Lua {
impl<'lua> LuaSchedulerExt<'lua> for Lua {
fn set_exit_code(&self, code: ExitCode) {
let exit = self
.app_data_ref::<Exit>()
.expect("exit code can only be set within a runtime");
.expect("exit code can only be set from within an active scheduler");
exit.set(code);
}
@ -299,7 +297,7 @@ impl<'lua> LuaRuntimeExt<'lua> for Lua {
) -> LuaResult<ThreadId> {
let queue = self
.app_data_ref::<SpawnedThreadQueue>()
.expect("lua threads can only be pushed within a runtime");
.expect("lua threads can only be pushed from within an active scheduler");
queue.push_item(self, thread, args)
}
@ -310,28 +308,28 @@ impl<'lua> LuaRuntimeExt<'lua> for Lua {
) -> LuaResult<ThreadId> {
let queue = self
.app_data_ref::<DeferredThreadQueue>()
.expect("lua threads can only be pushed within a runtime");
.expect("lua threads can only be pushed from within an active scheduler");
queue.push_item(self, thread, args)
}
fn track_thread(&'lua self, id: ThreadId) {
let map = self
.app_data_ref::<ThreadResultMap>()
.expect("lua threads can only be tracked within a runtime");
.expect("lua threads can only be tracked from within an active scheduler");
map.track(id);
}
fn get_thread_result(&'lua self, id: ThreadId) -> Option<LuaResult<LuaMultiValue<'lua>>> {
let map = self
.app_data_ref::<ThreadResultMap>()
.expect("lua threads results can only be retrieved within a runtime");
.expect("lua threads results can only be retrieved from within an active scheduler");
map.remove(id).map(|r| r.value(self))
}
fn wait_for_thread(&'lua self, id: ThreadId) -> impl Future<Output = ()> {
let map = self
.app_data_ref::<ThreadResultMap>()
.expect("lua threads results can only be retrieved within a runtime");
.expect("lua threads results can only be retrieved from within an active scheduler");
async move { map.listen(id).await }
}
}
@ -344,7 +342,7 @@ impl<'lua> LuaSpawnExt<'lua> for Lua {
{
let exec = self
.app_data_ref::<WeakArc<Executor>>()
.expect("tasks can only be spawned within a runtime")
.expect("tasks can only be spawned within an active scheduler")
.upgrade()
.expect("executor was dropped");
trace!("spawning future on executor");
@ -357,7 +355,7 @@ impl<'lua> LuaSpawnExt<'lua> for Lua {
{
let queue = self
.app_data_ref::<WeakRc<FuturesQueue>>()
.expect("tasks can only be spawned within a runtime")
.expect("tasks can only be spawned within an active scheduler")
.upgrade()
.expect("executor was dropped");
trace!("spawning local task on executor");
@ -371,7 +369,7 @@ impl<'lua> LuaSpawnExt<'lua> for Lua {
{
let exec = self
.app_data_ref::<WeakArc<Executor>>()
.expect("tasks can only be spawned within a runtime")
.expect("tasks can only be spawned within an active scheduler")
.upgrade()
.expect("executor was dropped");
trace!("spawning blocking task on executor");

2
lib/util.rs
View file

@ -9,7 +9,7 @@ use tracing::instrument;
Otherwise returns the values yielded by the thread, or the error that caused it to stop.
*/
#[instrument(level = "trace", name = "runtime::run_until_yield", skip_all)]
#[instrument(level = "trace", name = "scheduler::run_until_yield", skip_all)]
pub(crate) async fn run_until_yield<'lua>(
thread: LuaThread<'lua>,
args: LuaMultiValue<'lua>,