Use only non-send futures

android/Cargo.toml

@@ -12,7 +12,7 @@ categories.workspace = true
 authors.workspace = true
 
 [dependencies]
-maplibre = { path = "../maplibre", features = ["thread-safe-futures"] }
+maplibre = { path = "../maplibre", features = [] }
 maplibre-winit = { path = "../maplibre-winit", version = "0.1.0"  }
 env_logger.workspace = true
 log.workspace = true

apple/Cargo.toml

@@ -12,7 +12,7 @@ categories.workspace = true
 authors.workspace = true
 
 [dependencies]
-maplibre = { path = "../maplibre", features = ["thread-safe-futures"] }
+maplibre = { path = "../maplibre", features = [] }
 maplibre-winit = { path = "../maplibre-winit", version = "0.1.0"  }
 
 env_logger.workspace = true

benchmarks/Cargo.toml

@@ -12,7 +12,7 @@ categories.workspace = true
 authors.workspace = true
 
 [dependencies]
-maplibre = { path = "../maplibre", features = ["headless", "embed-static-tiles", "thread-safe-futures"] }
+maplibre = { path = "../maplibre", features = ["headless", "embed-static-tiles"] }
 
 [dev-dependencies]
 criterion.workspace = true

maplibre-demo/Cargo.toml

@@ -18,7 +18,7 @@ headless = ["maplibre/headless"]
 
 [dependencies]
 env_logger.workspace = true
-maplibre = { path = "../maplibre", version = "0.1.0", features = ["thread-safe-futures"]  }
+maplibre = { path = "../maplibre", version = "0.1.0", features = []  }
 maplibre-winit = { path = "../maplibre-winit", version = "0.1.0"  }
 tile-grid.workspace = true
 clap.workspace = true

maplibre-winit/src/lib.rs

@@ -6,7 +6,7 @@ use instant::Instant;
 use maplibre::{
     environment::{Environment, OffscreenKernelEnvironment},
     event_loop::{EventLoop, EventLoopProxy, SendEventError},
-    io::{apc::AsyncProcedureCall, scheduler::Scheduler, source_client::HttpClient},
+    io::{apc::AsyncProcedureCall, scheduler::ScheduleMethod, source_client::HttpClient},
     map::Map,
     window::{HeadedMapWindow, MapWindowConfig},
 };
@@ -191,7 +191,7 @@ impl<ET: 'static> EventLoopProxy<ET> for WinitEventLoopProxy<ET> {
 }
 
 pub struct WinitEnvironment<
-    S: Scheduler,
+    S: ScheduleMethod,
     HC: HttpClient,
     K: OffscreenKernelEnvironment,
     APC: AsyncProcedureCall<K>,
@@ -205,7 +205,7 @@ pub struct WinitEnvironment<
 }
 
 impl<
-        S: Scheduler,
+        S: ScheduleMethod,
         HC: HttpClient,
         K: OffscreenKernelEnvironment,
         APC: AsyncProcedureCall<K>,

maplibre-winit/src/noweb.rs

@@ -11,7 +11,7 @@ use maplibre::{
     kernel::{Kernel, KernelBuilder},
     map::Map,
     platform::{
-        http_client::ReqwestHttpClient, run_multithreaded, scheduler::TokioScheduler,
+        http_client::ReqwestHttpClient, run_multithreaded, scheduler::TokioScheduleMethod,
         ReqwestOffscreenKernelEnvironment,
     },
     raster::{DefaultRasterTransferables, RasterPlugin},
@@ -113,8 +113,8 @@ pub fn run_headed_map(
         let kernel: Kernel<Environment<_, _, _>> = KernelBuilder::new()
             .with_map_window_config(window_config)
             .with_http_client(client.clone())
-            .with_apc(SchedulerAsyncProcedureCall::new(TokioScheduler::new()))
-            .with_scheduler(TokioScheduler::new())
+            .with_apc(SchedulerAsyncProcedureCall::new(TokioScheduleMethod::new()))
+            .with_scheduler(TokioScheduleMethod::new())
             .build();
 
         let renderer_builder = RendererBuilder::new().with_wgpu_settings(wgpu_settings);

maplibre/Cargo.toml

@@ -18,7 +18,6 @@ default = ["raster"]
 web-webgl = ["wgpu/webgl"]
 # Enable tracing using tracy on desktop/mobile and the chrome profiler on web
 trace = ["tracing-subscriber", "tracing-tracy"]
-thread-safe-futures = []
 embed-static-tiles = ["maplibre-build-tools/sqlite"]
 headless = ["png"]
 raster = ["image"]

maplibre/src/environment.rs

@@ -1,7 +1,7 @@
 use crate::{
     io::{
         apc::AsyncProcedureCall,
-        scheduler::Scheduler,
+        scheduler::ScheduleMethod,
         source_client::{HttpClient, SourceClient},
     },
     window::MapWindowConfig,
@@ -20,7 +20,7 @@ pub trait Environment: 'static {
 
     type AsyncProcedureCall: AsyncProcedureCall<Self::OffscreenKernelEnvironment>;
 
-    type Scheduler: Scheduler;
+    type Scheduler: ScheduleMethod;
 
     type HttpClient: HttpClient;
 

maplibre/src/headless/environment.rs

@@ -3,7 +3,7 @@ use crate::{
     headless::window::HeadlessMapWindowConfig,
     io::apc::SchedulerAsyncProcedureCall,
     platform::{
-        http_client::ReqwestHttpClient, scheduler::TokioScheduler,
+        http_client::ReqwestHttpClient, scheduler::TokioScheduleMethod,
         ReqwestOffscreenKernelEnvironment,
     },
 };
@@ -14,7 +14,7 @@ impl Environment for HeadlessEnvironment {
     type MapWindowConfig = HeadlessMapWindowConfig;
     type AsyncProcedureCall =
         SchedulerAsyncProcedureCall<Self::OffscreenKernelEnvironment, Self::Scheduler>;
-    type Scheduler = TokioScheduler;
+    type Scheduler = TokioScheduleMethod;
     type HttpClient = ReqwestHttpClient;
     type OffscreenKernelEnvironment = ReqwestOffscreenKernelEnvironment;
 }

maplibre/src/headless/mod.rs

@@ -9,7 +9,7 @@ use crate::{
     },
     io::apc::SchedulerAsyncProcedureCall,
     kernel::{Kernel, KernelBuilder},
-    platform::{http_client::ReqwestHttpClient, scheduler::TokioScheduler},
+    platform::{http_client::ReqwestHttpClient, scheduler::TokioScheduleMethod},
     plugin::Plugin,
     render::{
         builder::RendererBuilder, graph::RenderGraph, tile_view_pattern::ViewTileSources,
@@ -37,8 +37,8 @@ pub async fn create_headless_renderer(
             WindowSize::new(tile_size, tile_size).unwrap(),
         ))
         .with_http_client(client.clone())
-        .with_apc(SchedulerAsyncProcedureCall::new(TokioScheduler::new()))
-        .with_scheduler(TokioScheduler::new())
+        .with_apc(SchedulerAsyncProcedureCall::new(TokioScheduleMethod::new()))
+        .with_scheduler(TokioScheduleMethod::new())
         .build();
 
     let mwc: &HeadlessMapWindowConfig = kernel.map_window_config();

maplibre/src/io/apc.rs

@@ -17,7 +17,7 @@ use thiserror::Error;
 
 use crate::{
     coords::WorldTileCoords, define_label, environment::OffscreenKernelEnvironment,
-    io::scheduler::Scheduler, style::Style,
+    io::scheduler::ScheduleMethod, style::Style,
 };
 
 define_label!(MessageTag);
@@ -99,10 +99,6 @@ pub enum ProcedureError {
     Send(SendError),
 }
 
-#[cfg(feature = "thread-safe-futures")]
-pub type AsyncProcedureFuture =
-    Pin<Box<(dyn Future<Output = Result<(), ProcedureError>> + Send + 'static)>>;
-#[cfg(not(feature = "thread-safe-futures"))]
 pub type AsyncProcedureFuture =
     Pin<Box<(dyn Future<Output = Result<(), ProcedureError>> + 'static)>>;
 
@@ -194,14 +190,14 @@ impl Context for SchedulerContext {
     }
 }
 
-pub struct SchedulerAsyncProcedureCall<K: OffscreenKernelEnvironment, S: Scheduler> {
+pub struct SchedulerAsyncProcedureCall<K: OffscreenKernelEnvironment, S: ScheduleMethod> {
     channel: (Sender<Message>, Receiver<Message>),
     buffer: RefCell<Vec<Message>>,
     scheduler: S,
     phantom_k: PhantomData<K>,
 }
 
-impl<K: OffscreenKernelEnvironment, S: Scheduler> SchedulerAsyncProcedureCall<K, S> {
+impl<K: OffscreenKernelEnvironment, S: ScheduleMethod> SchedulerAsyncProcedureCall<K, S> {
     pub fn new(scheduler: S) -> Self {
         Self {
             channel: mpsc::channel(),
@@ -212,7 +208,7 @@ impl<K: OffscreenKernelEnvironment, S: Scheduler> SchedulerAsyncProcedureCall<K,
     }
 }
 
-impl<K: OffscreenKernelEnvironment, S: Scheduler> AsyncProcedureCall<K>
+impl<K: OffscreenKernelEnvironment, S: ScheduleMethod> AsyncProcedureCall<K>
     for SchedulerAsyncProcedureCall<K, S>
 {
     type Context = SchedulerContext;

maplibre/src/io/scheduler.rs

@@ -14,16 +14,7 @@ pub enum ScheduleError {
 
 /// Async/await scheduler.
 /// Can schedule a task from a future factory and a shared state.
-pub trait Scheduler: 'static {
-    #[cfg(feature = "thread-safe-futures")]
-    fn schedule<T>(
-        &self,
-        future_factory: impl (FnOnce() -> T) + Send + 'static,
-    ) -> Result<(), ScheduleError>
-    where
-        T: Future<Output = ()> + Send + 'static;
-
-    #[cfg(not(feature = "thread-safe-futures"))]
+pub trait ScheduleMethod: 'static {
     fn schedule<T>(
         &self,
         future_factory: impl (FnOnce() -> T) + Send + 'static,
@@ -34,7 +25,7 @@ pub trait Scheduler: 'static {
 
 pub struct NopScheduler;
 
-impl Scheduler for NopScheduler {
+impl ScheduleMethod for NopScheduler {
     fn schedule<T>(
         &self,
         _future_factory: impl FnOnce() -> T + Send + 'static,

maplibre/src/io/source_client.rs

@@ -6,16 +6,12 @@ use thiserror::Error;
 use crate::{coords::WorldTileCoords, io::source_type::SourceType};
 
 /// A closure that returns a HTTP client.
-pub type HTTPClientFactory<HC> = dyn Fn() -> HC;
+pub type HttpClientFactory<HC> = dyn Fn() -> HC;
 
-/// On the web platform futures are not thread-safe (i.e. not Send). This means we need to tell
-/// async_trait that these bounds should not be placed on the async trait:
-/// [https://github.com/dtolnay/async-trait/blob/b70720c4c1cc0d810b7446efda44f81310ee7bf2/README.md#non-threadsafe-futures](https://github.com/dtolnay/async-trait/blob/b70720c4c1cc0d810b7446efda44f81310ee7bf2/README.md#non-threadsafe-futures)
-///
-/// Users of this library can decide whether futures from the HTTPClient are thread-safe or not via
-/// the future "thread-safe-futures". Tokio futures are thread-safe.
-#[cfg_attr(not(feature = "thread-safe-futures"), async_trait(?Send))]
-#[cfg_attr(feature = "thread-safe-futures", async_trait)]
+// On the web platform futures are not thread-safe (i.e. not Send). This means we need to tell
+// async_trait that these bounds should not be placed on the async trait:
+// https://github.com/dtolnay/async-trait/blob/b70720c4c1cc0d810b7446efda44f81310ee7bf2/README.md#non-threadsafe-futures
+#[async_trait(?Send)]
 pub trait HttpClient: Clone + Sync + Send + 'static {
     async fn fetch(&self, url: &str) -> Result<Vec<u8>, SourceFetchError>;
 }

maplibre/src/platform/noweb/http_client.rs

@@ -41,8 +41,7 @@ impl ReqwestHttpClient {
     }
 }
 
-#[cfg_attr(not(feature = "thread-safe-futures"), async_trait(?Send))]
-#[cfg_attr(feature = "thread-safe-futures", async_trait)]
+#[async_trait(?Send)]
 impl HttpClient for ReqwestHttpClient {
     async fn fetch(&self, url: &str) -> Result<Vec<u8>, SourceFetchError> {
         let response = self.client.get(url).send().await?;

maplibre/src/platform/noweb/scheduler.rs

@@ -1,43 +1,40 @@
 use std::future::Future;
 
-use crate::io::scheduler::{ScheduleError, Scheduler};
+use tokio_util::task::LocalPoolHandle;
+
+use crate::io::scheduler::{ScheduleError, ScheduleMethod};
 
 /// Multi-threading with Tokio.
-pub struct TokioScheduler;
+pub struct TokioScheduleMethod {
+    pool: LocalPoolHandle,
+}
 
-impl TokioScheduler {
+impl TokioScheduleMethod {
     pub fn new() -> Self {
-        Self {}
+        Self {
+            pool: LocalPoolHandle::new(4),
+        }
     }
 }
 
-impl Scheduler for TokioScheduler {
-    #[cfg(feature = "thread-safe-futures")]
+impl ScheduleMethod for TokioScheduleMethod {
     fn schedule<T>(
         &self,
-        future_factory: impl FnOnce() -> T + Send + 'static,
-    ) -> Result<(), ScheduleError>
-    where
-        T: Future<Output = ()> + Send + 'static,
-    {
-        tokio::task::spawn((future_factory)());
-        Ok(())
-    }
-
-    // FIXME: Provide a working implementation
-    #[cfg(not(feature = "thread-safe-futures"))]
-    fn schedule<T>(
-        &self,
-        _future_factory: impl FnOnce() -> T + 'static,
+        future_factory: impl FnOnce() -> T + 'static + Send,
     ) -> Result<(), ScheduleError>
     where
         T: Future<Output = ()> + 'static,
     {
+        self.pool.spawn_pinned(|| {
+            let unsend_data = (future_factory)();
+
+            async move { unsend_data.await }
+        });
         Ok(())
     }
 }
 
-impl Default for TokioScheduler {
+impl Default for TokioScheduleMethod {
     fn default() -> Self {
         Self::new()
     }

web/src/platform/multithreaded/pool_scheduler.rs

@@ -1,6 +1,6 @@
 use std::future::Future;
 
-use maplibre::{benchmarking::io::scheduler::ScheduleError, io::scheduler::Scheduler};
+use maplibre::{benchmarking::io::scheduler::ScheduleError, io::scheduler::ScheduleMethod};
 use wasm_bindgen::{prelude::*, JsCast};
 use web_sys::Worker;
 
@@ -27,7 +27,7 @@ impl WebWorkerPoolScheduler {
     }
 }
 
-impl Scheduler for WebWorkerPoolScheduler {
+impl ScheduleMethod for WebWorkerPoolScheduler {
     fn schedule<T>(
         &self,
         future_factory: impl (FnOnce() -> T) + Send + 'static,