Merge branch 'master' into master

Cargo.toml

@@ -57,7 +57,9 @@ bevy_sprite = { path = "crates/bevy_sprite", version = "0.1" }
 bevy_transform = { path = "crates/bevy_transform", version = "0.1" }
 bevy_text = { path = "crates/bevy_text", version = "0.1" }
 bevy_ui = { path = "crates/bevy_ui", version = "0.1" }
+bevy_utils = { path = "crates/bevy_utils", version = "0.1" }
 bevy_window = { path = "crates/bevy_window", version = "0.1" }
+bevy_tasks = { path = "crates/bevy_tasks", version = "0.1" }
 
 # bevy (optional)
 bevy_audio = { path = "crates/bevy_audio", optional = true, version = "0.1" }

crates/bevy_app/Cargo.toml

@@ -13,8 +13,10 @@ keywords = ["bevy"]
 # bevy
 bevy_derive = { path = "../bevy_derive", version = "0.1" }
 bevy_ecs = { path = "../bevy_ecs", version = "0.1" }
+bevy_tasks = { path = "../bevy_tasks", version = "0.1" }
+bevy_math = { path = "../bevy_math", version = "0.1" }
 
 # other
 libloading = "0.6"
 log = { version = "0.4", features = ["release_max_level_info"] }
-serde = { version = "1.0", features = ["derive"]}
+serde = { version = "1.0", features = ["derive"]}

crates/bevy_app/src/app.rs

@@ -1,4 +1,4 @@
-use crate::app_builder::AppBuilder;
+use crate::{app_builder::AppBuilder, DefaultTaskPoolOptions};
 use bevy_ecs::{ParallelExecutor, Resources, Schedule, World};
 
 #[allow(clippy::needless_doctest_main)]
@@ -63,6 +63,12 @@ impl App {
     }
 
     pub fn run(mut self) {
+        // Setup the default bevy task pools
+        self.resources
+            .get_cloned::<DefaultTaskPoolOptions>()
+            .unwrap_or_else(DefaultTaskPoolOptions::default)
+            .create_default_pools(&mut self.resources);
+
         self.startup_schedule.initialize(&mut self.resources);
         self.startup_executor.run(
             &mut self.startup_schedule,

crates/bevy_app/src/lib.rs

@@ -8,13 +8,15 @@ mod app_builder;
 mod event;
 mod plugin;
 mod schedule_runner;
+mod task_pool_options;
 
 pub use app::*;
 pub use app_builder::*;
 pub use bevy_derive::DynamicPlugin;
 pub use event::*;
 pub use plugin::*;
 pub use schedule_runner::*;
+pub use task_pool_options::*;
 
 pub mod prelude {
     pub use crate::{

crates/bevy_app/src/task_pool_options.rs

@@ -0,0 +1,147 @@
+use bevy_ecs::Resources;
+use bevy_tasks::{AsyncComputeTaskPool, ComputeTaskPool, IOTaskPool, TaskPoolBuilder};
+
+/// Defines a simple way to determine how many threads to use given the number of remaining cores
+/// and number of total cores
+#[derive(Clone)]
+pub struct TaskPoolThreadAssignmentPolicy {
+    /// Force using at least this many threads
+    pub min_threads: usize,
+    /// Under no circumstance use more than this many threads for this pool
+    pub max_threads: usize,
+    /// Target using this percentage of total cores, clamped by min_threads and max_threads. It is
+    /// permitted to use 1.0 to try to use all remaining threads
+    pub percent: f32,
+}
+
+impl TaskPoolThreadAssignmentPolicy {
+    /// Determine the number of threads to use for this task pool
+    fn get_number_of_threads(&self, remaining_threads: usize, total_threads: usize) -> usize {
+        assert!(self.percent >= 0.0);
+        let mut desired = (total_threads as f32 * self.percent).round() as usize;
+
+        // Limit ourselves to the number of cores available
+        desired = desired.min(remaining_threads);
+
+        // Clamp by min_threads, max_threads. (This may result in us using more threads than are
+        // available, this is intended. An example case where this might happen is a device with
+        // <= 2 threads.
+        bevy_math::clamp(desired, self.min_threads, self.max_threads)
+    }
+}
+
+/// Helper for configuring and creating the default task pools. For end-users who want full control,
+/// insert the default task pools into the resource map manually. If the pools are already inserted,
+/// this helper will do nothing.
+#[derive(Clone)]
+pub struct DefaultTaskPoolOptions {
+    /// If the number of physical cores is less than min_total_threads, force using min_total_threads
+    pub min_total_threads: usize,
+    /// If the number of physical cores is grater than max_total_threads, force using max_total_threads
+    pub max_total_threads: usize,
+
+    /// Used to determine number of IO threads to allocate
+    pub io: TaskPoolThreadAssignmentPolicy,
+    /// Used to determine number of async compute threads to allocate
+    pub async_compute: TaskPoolThreadAssignmentPolicy,
+    /// Used to determine number of compute threads to allocate
+    pub compute: TaskPoolThreadAssignmentPolicy,
+}
+
+impl Default for DefaultTaskPoolOptions {
+    fn default() -> Self {
+        DefaultTaskPoolOptions {
+            // By default, use however many cores are available on the system
+            min_total_threads: 1,
+            max_total_threads: std::usize::MAX,
+
+            // Use 25% of cores for IO, at least 1, no more than 4
+            io: TaskPoolThreadAssignmentPolicy {
+                min_threads: 1,
+                max_threads: 4,
+                percent: 0.25,
+            },
+
+            // Use 25% of cores for async compute, at least 1, no more than 4
+            async_compute: TaskPoolThreadAssignmentPolicy {
+                min_threads: 1,
+                max_threads: 4,
+                percent: 0.25,
+            },
+
+            // Use all remaining cores for compute (at least 1)
+            compute: TaskPoolThreadAssignmentPolicy {
+                min_threads: 1,
+                max_threads: std::usize::MAX,
+                percent: 1.0, // This 1.0 here means "whatever is left over"
+            },
+        }
+    }
+}
+
+impl DefaultTaskPoolOptions {
+    /// Create a configuration that forces using the given number of threads.
+    pub fn with_num_threads(thread_count: usize) -> Self {
+        let mut options = Self::default();
+        options.min_total_threads = thread_count;
+        options.max_total_threads = thread_count;
+
+        options
+    }
+
+    /// Inserts the default thread pools into the given resource map based on the configured values
+    pub fn create_default_pools(&self, resources: &mut Resources) {
+        let total_threads = bevy_math::clamp(
+            bevy_tasks::logical_core_count(),
+            self.min_total_threads,
+            self.max_total_threads,
+        );
+
+        let mut remaining_threads = total_threads;
+
+        if !resources.contains::<IOTaskPool>() {
+            // Determine the number of IO threads we will use
+            let io_threads = self
+                .io
+                .get_number_of_threads(remaining_threads, total_threads);
+            remaining_threads -= io_threads;
+
+            resources.insert(IOTaskPool(
+                TaskPoolBuilder::default()
+                    .num_threads(io_threads)
+                    .thread_name("IO Task Pool".to_string())
+                    .build(),
+            ));
+        }
+
+        if !resources.contains::<AsyncComputeTaskPool>() {
+            // Determine the number of async compute threads we will use
+            let async_compute_threads = self
+                .async_compute
+                .get_number_of_threads(remaining_threads, total_threads);
+            remaining_threads -= async_compute_threads;
+
+            resources.insert(AsyncComputeTaskPool(
+                TaskPoolBuilder::default()
+                    .num_threads(async_compute_threads)
+                    .thread_name("Async Compute Task Pool".to_string())
+                    .build(),
+            ));
+        }
+
+        if !resources.contains::<ComputeTaskPool>() {
+            // Determine the number of compute threads we will use
+            // This is intentionally last so that an end user can specify 1.0 as the percent
+            let compute_threads = self
+                .compute
+                .get_number_of_threads(remaining_threads, total_threads);
+
+            resources.insert(ComputeTaskPool(
+                TaskPoolBuilder::default()
+                    .num_threads(compute_threads)
+                    .thread_name("Compute Task Pool".to_string())
+                    .build(),
+            ));
+        }
+    }
+}

crates/bevy_asset/Cargo.toml

@@ -19,6 +19,7 @@ bevy_app = { path = "../bevy_app", version = "0.1" }
 bevy_ecs = { path = "../bevy_ecs", version = "0.1" }
 bevy_type_registry = { path = "../bevy_type_registry", version = "0.1" }
 bevy_property = { path = "../bevy_property", version = "0.1" }
+bevy_utils = { path = "../bevy_utils", version = "0.1" }
 
 # other
 uuid = { version = "0.8", features = ["v4", "serde"] }

crates/bevy_asset/src/asset_server.rs

@@ -4,10 +4,10 @@ use crate::{
 };
 use anyhow::Result;
 use bevy_ecs::{Res, Resource, Resources};
+use bevy_utils::{HashMap, HashSet};
 use crossbeam_channel::TryRecvError;
 use parking_lot::RwLock;
 use std::{
-    collections::{HashMap, HashSet},
     env, fs, io,
     path::{Path, PathBuf},
     sync::Arc,
@@ -185,7 +185,7 @@ impl AssetServer {
     #[cfg(feature = "filesystem_watcher")]
     pub fn filesystem_watcher_system(asset_server: Res<AssetServer>) {
         use notify::event::{Event, EventKind, ModifyKind};
-        let mut changed = HashSet::new();
+        let mut changed = HashSet::default();
 
         while let Some(filesystem_watcher) = asset_server.filesystem_watcher.read().as_ref() {
             let result = match filesystem_watcher.receiver.try_recv() {

crates/bevy_asset/src/assets.rs

@@ -5,7 +5,7 @@ use crate::{
 use bevy_app::{prelude::Events, AppBuilder};
 use bevy_ecs::{FromResources, IntoQuerySystem, ResMut, Resource};
 use bevy_type_registry::RegisterType;
-use std::collections::HashMap;
+use bevy_utils::HashMap;
 
 /// Events that happen on assets of type `T`
 pub enum AssetEvent<T: Resource> {

crates/bevy_core/Cargo.toml

@@ -15,4 +15,5 @@ bevy_derive = { path = "../bevy_derive", version = "0.1" }
 bevy_ecs = { path = "../bevy_ecs", version = "0.1" }
 bevy_property = { path = "../bevy_property", version = "0.1" }
 bevy_type_registry = { path = "../bevy_type_registry", version = "0.1" }
-bevy_math = { path = "../bevy_math", version = "0.1" }
+bevy_math = { path = "../bevy_math", version = "0.1" }
+bevy_utils = { path = "../bevy_utils", version = "0.1" }

crates/bevy_core/src/label.rs

@@ -1,8 +1,8 @@
 use bevy_ecs::prelude::*;
 use bevy_property::Properties;
+use bevy_utils::{HashMap, HashSet};
 use std::{
     borrow::Cow,
-    collections::{HashMap, HashSet},
     fmt::Debug,
     ops::{Deref, DerefMut},
 };
@@ -29,7 +29,7 @@ where
     T: IntoIterator<Item = L>,
 {
     fn from(value: T) -> Self {
-        let mut labels = HashSet::new();
+        let mut labels = HashSet::default();
         for label in value {
             labels.insert(label.into());
         }

crates/bevy_diagnostic/Cargo.toml

@@ -17,7 +17,8 @@ profiler = ["bevy_ecs/profiler"]
 bevy_app = { path = "../bevy_app", version = "0.1" }
 bevy_core = { path = "../bevy_core", version = "0.1" }
 bevy_ecs = { path = "../bevy_ecs", version = "0.1" }
+bevy_utils = { path = "../bevy_utils", version = "0.1" }
 
 # other
 uuid = { version = "0.8", features = ["v4", "serde"] }
-parking_lot = "0.10"
+parking_lot = "0.10"

crates/bevy_diagnostic/src/diagnostic.rs

@@ -1,5 +1,6 @@
+use bevy_utils::HashMap;
 use std::{
-    collections::{HashMap, VecDeque},
+    collections::VecDeque,
     time::{Duration, SystemTime},
 };
 use uuid::Uuid;

crates/bevy_diagnostic/src/system_profiler.rs

@@ -1,7 +1,8 @@
 use crate::{Diagnostic, DiagnosticId, Diagnostics};
 use bevy_ecs::{Profiler, Res, ResMut};
+use bevy_utils::HashMap;
 use parking_lot::RwLock;
-use std::{borrow::Cow, collections::HashMap, sync::Arc, time::Instant};
+use std::{borrow::Cow, sync::Arc, time::Instant};
 
 #[derive(Debug)]
 struct SystemRunInfo {

crates/bevy_ecs/Cargo.toml

@@ -15,8 +15,9 @@ profiler = []
 
 [dependencies]
 bevy_hecs = { path = "hecs", features = ["macros", "serialize"], version = "0.1" }
+bevy_tasks = { path = "../bevy_tasks", version = "0.1" }
+bevy_utils = { path = "../bevy_utils", version = "0.1" }
 rand = "0.7.2"
-rayon = "1.3"
 crossbeam-channel = "0.4.2"
 fixedbitset = "0.3.0"
 downcast-rs = "1.1.1"

crates/bevy_ecs/hecs/Cargo.toml

@@ -28,7 +28,7 @@ serialize = ["serde"]
 
 [dependencies]
 bevy_hecs_macros = { path = "macros", version = "0.1.3", optional = true }
-hashbrown = { version = "0.8.0", default-features = false, features = ["ahash", "inline-more"] }
+bevy_utils = { path = "../../bevy_utils", version = "0.1" }
 lazy_static = { version = "1.4.0", optional = true, features = ["spin_no_std"] }
 serde = { version = "1", features = ["derive"], optional = true}
 rand = "0.7.3"

crates/bevy_ecs/hecs/macros/src/lib.rs

@@ -83,7 +83,7 @@ pub fn derive_bundle(input: TokenStream) -> TokenStream {
 
                 #path::lazy_static::lazy_static! {
                     static ref ELEMENTS: [TypeId; #n] = {
-                        let mut dedup = std::collections::HashSet::new();
+                        let mut dedup = #path::bevy_utils::HashSet::default();
                         for &(ty, name) in [#((std::any::TypeId::of::<#tys>(), std::any::type_name::<#tys>())),*].iter() {
                             if !dedup.insert(ty) {
                                 panic!("{} has multiple {} fields; each type must occur at most once!", stringify!(#ident), name);

crates/bevy_ecs/hecs/src/archetype.rs

@@ -20,15 +20,14 @@ use crate::alloc::{
     vec,
     vec::Vec,
 };
+use bevy_utils::{HashMap, HashMapExt};
 use core::{
     any::{type_name, TypeId},
     cell::UnsafeCell,
     mem,
     ptr::{self, NonNull},
 };
 
-use hashbrown::HashMap;
-
 use crate::{borrow::AtomicBorrow, query::Fetch, Access, Component, Query};
 
 /// A collection of entities having the same component types

crates/bevy_ecs/hecs/src/entities.rs

@@ -1,7 +1,7 @@
 // modified by Bevy contributors
 
+use bevy_utils::HashMap;
 use core::fmt;
-use hashbrown::HashMap;
 #[cfg(feature = "std")]
 use std::error::Error;
 

crates/bevy_ecs/hecs/src/entity_builder.rs

@@ -20,14 +20,14 @@ use crate::alloc::{
     vec,
     vec::Vec,
 };
+
+use bevy_utils::HashSet;
 use core::{
     any::TypeId,
     mem::{self, MaybeUninit},
     ptr,
 };
 
-use hashbrown::HashSet;
-
 use crate::{archetype::TypeInfo, Component, DynamicBundle};
 
 /// Helper for incrementally constructing a bundle of components with dynamic component types
@@ -59,7 +59,7 @@ impl EntityBuilder {
             storage: Box::new([]),
             info: Vec::new(),
             ids: Vec::new(),
-            id_set: HashSet::new(),
+            id_set: HashSet::default(),
         }
     }
 

crates/bevy_ecs/hecs/src/lib.rs

@@ -89,6 +89,8 @@ pub use world::{ArchetypesGeneration, Component, ComponentError, Iter, SpawnBatc
 // Unstable implementation details needed by the macros
 #[doc(hidden)]
 pub use archetype::TypeInfo;
+#[doc(hidden)]
+pub use bevy_utils;
 #[cfg(feature = "macros")]
 #[doc(hidden)]
 pub use lazy_static;