Try #7267:

Author: bors[bot]

.github/contributing/example_style_guide.md

@@ -38,7 +38,7 @@ For more advice on writing examples, see the [relevant section](../../CONTRIBUTI
 4. In Queries, prefer `With<T>` filters over actually fetching unused data with `&T`.
 5. Prefer disjoint queries using `With` and `Without` over param sets when you need more than one query in a single system.
 6. Prefer structs with named fields over tuple structs except in the case of single-field wrapper types.
-7. Use enum-labels over string-labels for system / stage / etc. labels.
+7. Use enum-labels over string-labels for system / schedule / etc. labels.
 
 ## "Feature" examples
 

Cargo.toml

@@ -920,7 +920,7 @@ path = "examples/ecs/removal_detection.rs"
 
 [package.metadata.example.removal_detection]
 name = "Removal Detection"
-description = "Query for entities that had a specific component removed in a previous stage during the current frame"
+description = "Query for entities that had a specific component removed earlier in the current frame"
 category = "ECS (Entity Component System)"
 wasm = false
 
@@ -974,16 +974,6 @@ description = "Illustrates creating custom system parameters with `SystemParam`"
 category = "ECS (Entity Component System)"
 wasm = false
 
-[[example]]
-name = "system_sets"
-path = "examples/ecs/system_sets.rs"
-
-[package.metadata.example.system_sets]
-name = "System Sets"
-description = "Shows `SystemSet` use along with run criterion"
-category = "ECS (Entity Component System)"
-wasm = false
-
 [[example]]
 name = "timers"
 path = "examples/ecs/timers.rs"

benches/benches/bevy_ecs/components/archetype_updates.rs

@@ -1,22 +1,18 @@
-use bevy_ecs::{
-    component::Component,
-    schedule::{Stage, SystemStage},
-    world::World,
-};
+use bevy_ecs::{component::Component, schedule_v3::Schedule, world::World};
 use criterion::{BenchmarkId, Criterion};
 
 #[derive(Component)]
 struct A<const N: u16>(f32);
 
-fn setup(system_count: usize) -> (World, SystemStage) {
+fn setup(system_count: usize) -> (World, Schedule) {
     let mut world = World::new();
     fn empty() {}
-    let mut stage = SystemStage::parallel();
+    let mut schedule = Schedule::new();
     for _ in 0..system_count {
-        stage.add_system(empty);
+        schedule.add_system(empty);
     }
-    stage.run(&mut world);
-    (world, stage)
+    schedule.run(&mut world);
+    (world, schedule)
 }
 
 /// create `count` entities with distinct archetypes
@@ -78,13 +74,13 @@ pub fn no_archetypes(criterion: &mut Criterion) {
     let mut group = criterion.benchmark_group("no_archetypes");
     for i in 0..=5 {
         let system_count = i * 20;
-        let (mut world, mut stage) = setup(system_count);
+        let (mut world, mut schedule) = setup(system_count);
         group.bench_with_input(
             BenchmarkId::new("system_count", system_count),
             &system_count,
             |bencher, &_system_count| {
                 bencher.iter(|| {
-                    stage.run(&mut world);
+                    schedule.run(&mut world);
                 });
             },
         );
@@ -101,12 +97,12 @@ pub fn added_archetypes(criterion: &mut Criterion) {
             |bencher, &archetype_count| {
                 bencher.iter_batched(
                     || {
-                        let (mut world, stage) = setup(SYSTEM_COUNT);
+                        let (mut world, schedule) = setup(SYSTEM_COUNT);
                         add_archetypes(&mut world, archetype_count);
-                        (world, stage)
+                        (world, schedule)
                     },
-                    |(mut world, mut stage)| {
-                        stage.run(&mut world);
+                    |(mut world, mut schedule)| {
+                        schedule.run(&mut world);
                     },
                     criterion::BatchSize::LargeInput,
                 );

benches/benches/bevy_ecs/empty_archetypes.rs

@@ -1,9 +1,4 @@
-use bevy_ecs::{
-    component::Component,
-    prelude::*,
-    schedule::{Stage, SystemStage},
-    world::World,
-};
+use bevy_ecs::{component::Component, prelude::*, world::World};
 use bevy_tasks::{ComputeTaskPool, TaskPool};
 use criterion::{black_box, criterion_group, criterion_main, BenchmarkId, Criterion};
 
@@ -80,14 +75,14 @@ fn par_for_each(
     });
 }
 
-fn setup(parallel: bool, setup: impl FnOnce(&mut SystemStage)) -> (World, SystemStage) {
+fn setup(parallel: bool, setup: impl FnOnce(&mut Schedule)) -> (World, Schedule) {
     let mut world = World::new();
-    let mut stage = SystemStage::parallel();
+    let mut schedule = Schedule::new();
     if parallel {
         world.insert_resource(ComputeTaskPool(TaskPool::default()));
     }
-    setup(&mut stage);
-    (world, stage)
+    setup(&mut schedule);
+    (world, schedule)
 }
 
 /// create `count` entities with distinct archetypes
@@ -158,8 +153,8 @@ fn add_archetypes(world: &mut World, count: u16) {
 fn empty_archetypes(criterion: &mut Criterion) {
     let mut group = criterion.benchmark_group("empty_archetypes");
     for archetype_count in [10, 100, 500, 1000, 2000, 5000, 10000] {
-        let (mut world, mut stage) = setup(true, |stage| {
-            stage.add_system(iter);
+        let (mut world, mut schedule) = setup(true, |schedule| {
+            schedule.add_system(iter);
         });
         add_archetypes(&mut world, archetype_count);
         world.clear_entities();
@@ -177,20 +172,20 @@ fn empty_archetypes(criterion: &mut Criterion) {
         e.insert(A::<10>(1.0));
         e.insert(A::<11>(1.0));
         e.insert(A::<12>(1.0));
-        stage.run(&mut world);
+        schedule.run(&mut world);
         group.bench_with_input(
             BenchmarkId::new("iter", archetype_count),
             &archetype_count,
             |bencher, &_| {
                 bencher.iter(|| {
-                    stage.run(&mut world);
+                    schedule.run(&mut world);
                 })
             },
         );
     }
     for archetype_count in [10, 100, 500, 1000, 2000, 5000, 10000] {
-        let (mut world, mut stage) = setup(true, |stage| {
-            stage.add_system(for_each);
+        let (mut world, mut schedule) = setup(true, |schedule| {
+            schedule.add_system(for_each);
         });
         add_archetypes(&mut world, archetype_count);
         world.clear_entities();
@@ -208,20 +203,20 @@ fn empty_archetypes(criterion: &mut Criterion) {
         e.insert(A::<10>(1.0));
         e.insert(A::<11>(1.0));
         e.insert(A::<12>(1.0));
-        stage.run(&mut world);
+        schedule.run(&mut world);
         group.bench_with_input(
             BenchmarkId::new("for_each", archetype_count),
             &archetype_count,
             |bencher, &_| {
                 bencher.iter(|| {
-                    stage.run(&mut world);
+                    schedule.run(&mut world);
                 })
             },
         );
     }
     for archetype_count in [10, 100, 500, 1000, 2000, 5000, 10000] {
-        let (mut world, mut stage) = setup(true, |stage| {
-            stage.add_system(par_for_each);
+        let (mut world, mut schedule) = setup(true, |schedule| {
+            schedule.add_system(par_for_each);
         });
         add_archetypes(&mut world, archetype_count);
         world.clear_entities();
@@ -239,13 +234,13 @@ fn empty_archetypes(criterion: &mut Criterion) {
         e.insert(A::<10>(1.0));
         e.insert(A::<11>(1.0));
         e.insert(A::<12>(1.0));
-        stage.run(&mut world);
+        schedule.run(&mut world);
         group.bench_with_input(
             BenchmarkId::new("par_for_each", archetype_count),
             &archetype_count,
             |bencher, &_| {
                 bencher.iter(|| {
-                    stage.run(&mut world);
+                    schedule.run(&mut world);
                 })
             },
         );

benches/benches/bevy_ecs/scheduling/mod.rs

@@ -1,19 +1,17 @@
 use criterion::criterion_group;
 
 mod run_criteria;
+mod running_systems;
 mod schedule;
-mod stages;
 
 use run_criteria::*;
+use running_systems::*;
 use schedule::*;
-use stages::*;
 
 criterion_group!(
     scheduling_benches,
     run_criteria_yes,
     run_criteria_no,
-    run_criteria_yes_with_labels,
-    run_criteria_no_with_labels,
     run_criteria_yes_with_query,
     run_criteria_yes_with_resource,
     empty_systems,