Skip to content

Commit

Permalink
Merge branch 'main' into cb/add-disconnection-error
Browse files Browse the repository at this point in the history
  • Loading branch information
cBournhonesque authored May 29, 2024
2 parents 3cedb3a + 6c56e4d commit 2326bb6
Show file tree
Hide file tree
Showing 19 changed files with 531 additions and 318 deletions.
5 changes: 3 additions & 2 deletions benches/Cargo.toml
Original file line number Diff line number Diff line change
Expand Up @@ -14,6 +14,7 @@ license = "MIT OR Apache-2.0"

[dependencies]
lightyear = { path = "../lightyear" }
criterion = { version = "0.3", features = ["html_reports"] }
crossbeam-channel = "0.5.10"
anyhow = { version = "1.0.75", features = [] }
bevy = { version = "0.13", features = ["bevy_core_pipeline"] }
Expand All @@ -28,8 +29,8 @@ lz4_flex = { version = "0.11.2", default-features = false }


[[bench]]
name = "spawn"
path = "spawn.rs"
name = "replication"
path = "replication.rs"
harness = false

[[bench]]
Expand Down
105 changes: 49 additions & 56 deletions benches/message.rs
Original file line number Diff line number Diff line change
Expand Up @@ -7,7 +7,6 @@ use bevy::prelude::{default, error, Events};
use bevy::utils::tracing;
use bevy::utils::tracing::Level;
use bevy::utils::Duration;
use divan::{AllocProfiler, Bencher};
use lightyear::client::sync::SyncConfig;
use lightyear::prelude::client::{InterpolationConfig, PredictionConfig};
use lightyear::prelude::{client, server, MessageRegistry, Tick, TickManager};
Expand All @@ -17,64 +16,58 @@ use lightyear::shared::replication::network_target::NetworkTarget;
use lightyear_benches::local_stepper::{LocalBevyStepper, Step as LocalStep};
use lightyear_benches::protocol::*;

fn main() {
divan::main()
}
use criterion::{criterion_group, criterion_main, BatchSize, Criterion};

// #[global_allocator]
// static ALLOC: AllocProfiler = AllocProfiler::system();
criterion_group!(message_benches, send_receive_simple_messages_to_one_client);
criterion_main!(message_benches);

const NUM_MESSAGE: &[usize] = &[0, 10, 100, 1000, 10000];

/// Sending N message from server to channel, with a local io
#[divan::bench(
sample_count = 100,
args = NUM_MESSAGE,
)]
fn send_message(bencher: Bencher, n: usize) {
bencher
.with_inputs(|| {
let frame_duration = Duration::from_secs_f32(1.0 / 60.0);
let tick_duration = Duration::from_millis(10);
let shared_config = SharedConfig {
tick: TickConfig::new(tick_duration),
..default()
};
let mut stepper = LocalBevyStepper::new(
1,
shared_config,
SyncConfig::default(),
PredictionConfig::default(),
InterpolationConfig::default(),
frame_duration,
);
stepper.init();

let client_id = ClientId::Netcode(0);
for _ in 0..n {
let _ = stepper
.server_app
.world
.resource_mut::<server::ConnectionManager>()
.send_message::<Channel1, _>(client_id, &Message2(1))
.inspect_err(|e| error!("error: {e:?}"));
}
stepper
})
.bench_values(|mut stepper| {
let client_id = ClientId::Netcode(0);
stepper.frame_step();
assert_eq!(
stepper
.client_apps
.get_mut(&client_id)
.unwrap()
.world
.resource_mut::<Events<client::MessageEvent<Message2>>>()
.drain()
.map(|e| e.message().clone())
.collect::<Vec<_>>(),
vec![Message2(1); n]
);
});
fn send_receive_simple_messages_to_one_client(criterion: &mut Criterion) {
let mut group =
criterion.benchmark_group("message/send_receive_simplek w_messages_to_one_client");
group.warm_up_time(std::time::Duration::from_millis(500));
group.measurement_time(std::time::Duration::from_millis(3000));
for n in NUM_MESSAGE.iter() {
group.bench_with_input(
criterion::BenchmarkId::new("num_messages", n),
n,
|bencher, n| {
bencher.iter_batched_ref(
|| LocalBevyStepper::default(),
|mut stepper| {
let client_id = ClientId::Netcode(0);
for _ in 0..*n {
let _ = stepper
.server_app
.world
.resource_mut::<server::ConnectionManager>()
.send_message::<Channel1, _>(client_id, &Message2(1))
.inspect_err(|e| error!("error: {e:?}"));
}
stepper.frame_step();
// assert_eq!(
// stepper
// .client_apps
// .get_mut(&client_id)
// .unwrap()
// .world
// .resource_mut::<Events<client::MessageEvent<Message2>>>()
// .drain()
// .map(|e| e.message)
// .collect::<Vec<_>>(),
// vec![Message2(1); *n]
// );
},
BatchSize::LargeInput,
);
},
);
}
group.finish();
}

// TODO: send_receive_long_message_to_one_client
// TODO: send_receive_random_message_to_one_client (with fuzzing)
// TODO: send_receive_simple_message_to_many_clients
117 changes: 117 additions & 0 deletions benches/replication.rs
Original file line number Diff line number Diff line change
@@ -0,0 +1,117 @@
//! Benchmark to measure the performance of replicating Entity spawns
#![allow(unused_imports)]

use bevy::log::tracing_subscriber::fmt::format::FmtSpan;
use bevy::log::{info, tracing_subscriber};
use bevy::prelude::{default, error, Events};
use bevy::utils::tracing;
use bevy::utils::tracing::Level;
use bevy::utils::Duration;
use divan::{AllocProfiler, Bencher};
use lightyear::client::sync::SyncConfig;
use lightyear::prelude::client::{
ClientConnection, InterpolationConfig, NetClient, PredictionConfig,
};
use lightyear::prelude::server::Replicate;
use lightyear::prelude::{client, server, MessageRegistry, Tick, TickManager};
use lightyear::prelude::{ClientId, SharedConfig, TickConfig};
use lightyear::server::input::native::InputBuffers;
use lightyear::shared::replication::network_target::NetworkTarget;
use lightyear_benches::local_stepper::{LocalBevyStepper, Step as LocalStep};
use lightyear_benches::protocol::*;

use criterion::{criterion_group, criterion_main, BatchSize, Criterion};

criterion_group!(
replication_benches,
replicate_simple_component_to_one_client,
replicate_simple_component_to_multiple_clients
);
criterion_main!(replication_benches);

const NUM_ENTITIES: &[usize] = &[0, 10, 100, 1000, 10000];

/// Replicating N entity spawn from server to channel, with a local io
fn replicate_simple_component_to_one_client(criterion: &mut Criterion) {
let mut group = criterion.benchmark_group("replication/replicate_simple_message_to_one_client");
group.warm_up_time(std::time::Duration::from_millis(500));
group.measurement_time(std::time::Duration::from_millis(6000));
for n in NUM_ENTITIES.iter() {
group.bench_with_input(
criterion::BenchmarkId::new("num_entities", n),
n,
|bencher, n| {
bencher.iter_batched_ref(
|| {
let mut stepper = LocalBevyStepper::default();
let entities = vec![(Component1(0.0), Replicate::default()); *n];
stepper.server_app.world.spawn_batch(entities);
stepper
},
|stepper| {
stepper.frame_step();
// let client_id = ClientId::Netcode(0);
// assert_eq!(
// stepper
// .client_apps
// .get(&client_id)
// .unwrap()
// .world
// .entities()
// .len(),
// n as u32
// );
},
BatchSize::LargeInput,
);
},
);
}
group.finish();
}

const FIXED_NUM_ENTITIES: usize = 10;
const NUM_CLIENTS: &[usize] = &[0, 1, 2, 4, 8, 16];

/// Replicating entity spawns from server to N clients, with a socket io
fn replicate_simple_component_to_multiple_clients(criterion: &mut Criterion) {
let mut group =
criterion.benchmark_group("replication/replicate_simple_component_to_multiple_client");
group.warm_up_time(std::time::Duration::from_millis(500));
group.measurement_time(std::time::Duration::from_millis(6000));
for n in NUM_CLIENTS.iter() {
group.bench_with_input(
criterion::BenchmarkId::new("num_clients", n),
n,
|bencher, n| {
bencher.iter_batched_ref(
|| {
let mut stepper = LocalBevyStepper::default_n_clients(*n);
let entities =
vec![(Component1(0.0), Replicate::default()); FIXED_NUM_ENTITIES];
stepper.server_app.world.spawn_batch(entities);
stepper
},
|stepper| {
stepper.frame_step();
// for i in 0..*n {
// let client_id = ClientId::Netcode(i as u64);
// assert_eq!(
// stepper
// .client_apps
// .get(&client_id)
// .unwrap()
// .world
// .entities()
// .len(),
// FIXED_NUM_ENTITIES as u32
// );
// }
},
BatchSize::LargeInput,
);
},
);
}
group.finish();
}
125 changes: 0 additions & 125 deletions benches/spawn.rs

This file was deleted.

Loading

0 comments on commit 2326bb6

Please sign in to comment.