mirror of
https://gitlab.freedesktop.org/gstreamer/gst-plugins-rs.git
synced 2024-06-13 19:59:25 +00:00
6163589ac7
The threadshare executor was based on a modified version of tokio which implemented the throttling strategy in the BasicScheduler. Upstream tokio codebase has significantly diverged from what it was when the throttling strategy was implemented making it hard to follow. This means that we can hardly get updates from the upstream project and when we cherry pick fixes, we can't reflect the state of the project on our fork's version. As a consequence, tools such as cargo-deny can't check for RUSTSEC fixes in our fork. The smol ecosystem makes it quite easy to implement and maintain a custom async executor. This MR imports the smol parts that need modifications to comply with the threadshare model and implements a throttling executor in place of the tokio fork. Networking tokio specific types are replaced with Async wrappers in the spirit of [smol-rs/async-io]. Note however that the Async wrappers needed modifications in order to use the per thread Reactor model. This means that higher level upstream networking crates such as [async-net] can not be used with our Async implementation. Based on the example benchmark with ts-udpsrc, performances seem on par with what we achieved using the tokio fork. Fixes https://gitlab.freedesktop.org/gstreamer/gst-plugins-rs/-/issues/118 Related to https://gitlab.freedesktop.org/gstreamer/gst-plugins-rs/-/merge_requests/604
59 lines
2.4 KiB
Rust
59 lines
2.4 KiB
Rust
// Copyright (C) 2019-2021 François Laignel <fengalin@free.fr>
|
|
//
|
|
// Take a look at the license at the top of the repository in the LICENSE file.
|
|
|
|
//! A `runtime` for the `threadshare` GStreamer plugins framework.
|
|
//!
|
|
//! Many `GStreamer` `Element`s internally spawn OS `thread`s. For most applications, this is not an
|
|
//! issue. However, in applications which process many `Stream`s in parallel, the high number of
|
|
//! `threads` leads to reduced efficiency due to:
|
|
//!
|
|
//! * context switches,
|
|
//! * scheduler overhead,
|
|
//! * most of the threads waiting for some resources to be available.
|
|
//!
|
|
//! The `threadshare` `runtime` is a framework to build `Element`s for such applications. It
|
|
//! uses light-weight threading to allow multiple `Element`s share a reduced number of OS `thread`s.
|
|
//!
|
|
//! See this [talk] ([slides]) for a presentation of the motivations and principles,
|
|
//! and this [blog post].
|
|
//!
|
|
//! Current implementation uses a custom executor mostly based on the [`smol`] ecosystem.
|
|
//!
|
|
//! Most `Element`s implementations should use the high-level features provided by [`PadSrc`] &
|
|
//! [`PadSink`].
|
|
//!
|
|
//! [talk]: https://gstconf.ubicast.tv/videos/when-adding-more-threads-adds-more-problems-thread-sharing-between-elements-in-gstreamer/
|
|
//! [slides]: https://gstreamer.freedesktop.org/data/events/gstreamer-conference/2018/Sebastian%20Dr%C3%B6ge%20-%20When%20adding%20more%20threads%20adds%20more%20problems:%20Thread-sharing%20between%20elements%20in%20GStreamer.pdf
|
|
//! [blog post]: https://coaxion.net/blog/2018/04/improving-gstreamer-performance-on-a-high-number-of-network-streams-by-sharing-threads-between-elements-with-rusts-tokio-crate
|
|
//! [`smol`]: https://github.com/smol-rs/
|
|
//! [`PadSrc`]: pad/struct.PadSrc.html
|
|
//! [`PadSink`]: pad/struct.PadSink.html
|
|
|
|
pub mod executor;
|
|
pub use executor::{Async, Context, JoinHandle, SubTaskOutput, Timer};
|
|
|
|
pub mod pad;
|
|
pub use pad::{PadSink, PadSinkRef, PadSinkWeak, PadSrc, PadSrcRef, PadSrcWeak};
|
|
|
|
pub mod task;
|
|
pub use task::{Task, TaskState};
|
|
|
|
pub mod prelude {
|
|
pub use super::pad::{PadSinkHandler, PadSrcHandler};
|
|
pub use super::task::TaskImpl;
|
|
}
|
|
|
|
pub mod time;
|
|
pub use time::{delay_for, delay_for_at_least};
|
|
|
|
use once_cell::sync::Lazy;
|
|
|
|
static RUNTIME_CAT: Lazy<gst::DebugCategory> = Lazy::new(|| {
|
|
gst::DebugCategory::new(
|
|
"ts-runtime",
|
|
gst::DebugColorFlags::empty(),
|
|
Some("Thread-sharing Runtime"),
|
|
)
|
|
});
|