feat: add broadcast crate (hyperion-mc#83)

Author: andrewgazelka

Cargo.lock

@@ -1,5 +1,6 @@
 # https://doc.rust-lang.org/rustc/profile-guided-optimization.html
 # https://nikolaivazquez.com/blog/divan/#measure-allocations
+# https://doc.rust-lang.org/cargo/reference/profiles.html
 
 [workspace]
 resolver = "2"
@@ -8,7 +9,8 @@ members = [
     "server",
     "chunk",
     "generator-build",
-    "generator"
+    "generator",
+    "broadcast",
 ]
 
 [profile.dev]
@@ -21,17 +23,15 @@ opt-level = 3
 #debug = true
 lto = "fat"
 codegen-units = 1
-#strip = false
-#panic = "abort"
+panic = "abort"
 
 [profile.bench]
-debug = true
-lto = false
-#lto = "fat"
-#codegen-units = 1
-#panic = "abort"
+#debug = true
+lto = "fat"
+codegen-units = 1
 
 [workspace.dependencies]
 chunk = { path = "chunk" }
 generator-build = { path = "generator-build" }
 generator = { path = "generator" }
+broadcast = { path = "broadcast" }

Cargo.toml

@@ -34,9 +34,13 @@ COPY Cargo.toml Cargo.lock ./
 COPY chunk/Cargo.toml ./chunk/Cargo.toml
 COPY chunk/src ./chunk/src
 
+COPY broadcast/Cargo.toml ./broadcast/Cargo.toml
+COPY broadcast/benches ./broadcast/benches
+COPY broadcast/src ./broadcast/src
+
 COPY generator/Cargo.toml ./generator/Cargo.toml
 COPY generator/build.rs ./generator/build.rs
-COPY generator/generated.zip ./generator/generated.zip
+COPY generator/generated.tar.zst ./generator/generated.tar.zst
 COPY generator/src ./generator/src
 
 COPY generator-build/Cargo.toml ./generator-build/Cargo.toml
@@ -109,12 +113,3 @@ RUN --mount=type=cache,target=/cargo-home \
     IAI_CALLGRIND_RUNNER=/cargo-home/bin/iai-callgrind-runner cargo bench --locked > /app/bench.txt
 
 RUN cat /app/bench.txt
-
-
-
-
-#FROM alpine:3.19 as cli
-#
-## timings
-#COPY --from=debug /build/cargo-timing.html /app/cargo-timing.html
-

Dockerfile

@@ -0,0 +1 @@
+/target

broadcast/.gitignore

@@ -0,0 +1,33 @@
+[package]
+name = "broadcast"
+version = "0.1.0"
+edition = "2021"
+authors = ["Andrew Gazelka <[email protected]>"]
+readme = "README.md"
+publish = false
+
+[dependencies]
+anyhow = "1.0.81"
+
+[dev-dependencies]
+divan = "0.1.14"
+rand = "0.8.5"
+
+[[bench]]
+name = "group"
+harness = false
+
+[[bench]]
+name = "world"
+harness = false
+
+[lints.clippy]
+complexity = "deny"
+
+nursery = { level = "deny", priority = -1 }
+redundant_pub_crate = "allow"
+
+pedantic = "deny"
+perf = "deny"
+style = "deny"
+suspicious = "deny"

broadcast/Cargo.toml

@@ -0,0 +1 @@
+# broadcast

broadcast/README.md

@@ -0,0 +1,55 @@
+use std::hint::black_box;
+
+use broadcast::utils::group::group;
+use divan::{AllocProfiler, Bencher};
+use rand::prelude::SliceRandom;
+
+#[global_allocator]
+static ALLOC: AllocProfiler = AllocProfiler::system();
+
+fn main() {
+    divan::main();
+}
+
+// say render distance is 32 chunks
+// this means we have 32 * 32 = 1024 chunks we will have to go through
+const LENS: &[u32] = &[64, 128, 256, 512, 1024, 2048];
+
+// Register a `fibonacci` function and benchmark it over multiple cases.
+#[divan::bench(
+    args = LENS,
+)]
+fn contiguous(bencher: Bencher, len: u32) {
+    let v = (0..len).collect::<Vec<_>>();
+
+    bencher.counter(len).bench(|| {
+        group(&v).for_each(|elem| {
+            black_box(elem);
+        });
+    });
+}
+
+#[divan::bench(
+    args = LENS,
+)]
+fn random_eighth(bencher: Bencher, len: u32) {
+    let mut v: Vec<_> = (0..len).collect();
+
+    // shuffle using rand
+    v.shuffle(&mut rand::thread_rng());
+
+    let eigth = len / 8;
+
+    let idxes = &mut v[..eigth as usize];
+
+    // sort
+    idxes.sort_unstable();
+
+    let idxes = &v[..eigth as usize];
+
+    bencher.counter(len).bench(|| {
+        group(idxes).for_each(|elem| {
+            black_box(elem);
+        });
+    });
+}

broadcast/benches/group.rs

@@ -0,0 +1,81 @@
+#![feature(thread_local)]
+
+use std::{cell::RefCell, collections::BTreeMap, hint::black_box};
+
+use broadcast::Broadcaster;
+use divan::Bencher;
+
+// #[global_allocator]
+// static ALLOC: AllocProfiler = AllocProfiler::system();
+
+fn main() {
+    divan::main();
+}
+
+// say render distance is 32 chunks
+// this means we have 32 * 32 = 1024 chunks we will have to go through
+// const LENS: &[u16] = &[1, 2, 4, 8, 16, 32, 64];
+const LENS: &[u16] = &[128, 256, 512, 1024];
+
+#[inline(never)]
+fn generate_world(width: u16) -> Broadcaster {
+    let mut world = Broadcaster::create(width).unwrap();
+
+    world.populate(|_, data| {
+        let data_len = rand::random::<u8>();
+        let to_push = (0..data_len)
+            .map(|_| rand::random::<u8>())
+            .collect::<Vec<_>>();
+
+        data.extend(to_push);
+    });
+
+    world
+}
+
+// for normal (x, y) -> x + y * width
+// world                         fastest       │ slowest       │ median        │ mean          │
+// samples │ iters ╰─ player_render_distance_32                │               │               │
+// │         │    ├─ 128                     709.6 µs      │ 1.138 ms      │ 785.8 µs      │ 827.8
+// µs      │ 100     │ 100    │                          14.09 Mitem/s │ 8.78 Mitem/s  │ 12.72
+// Mitem/s │ 12.07 Mitem/s │         │    ├─ 256                     835.8 µs      │ 1.078 ms      │
+// 937.8 µs      │ 935.2 µs      │ 100     │ 100    │                          11.96 Mitem/s │ 9.268
+// Mitem/s │ 10.66 Mitem/s │ 10.69 Mitem/s │         │    ├─ 512                     1.004 ms      │
+// 1.319 ms      │ 1.124 ms      │ 1.114 ms      │ 100     │ 100    │                          9.952
+// Mitem/s │ 7.576 Mitem/s │ 8.893 Mitem/s │ 8.969 Mitem/s │         │    ╰─ 1024
+// 1.037 ms      │ 1.336 ms      │ 1.132 ms      │ 1.138 ms      │ 100     │ 100
+// 9.639 Mitem/s │ 7.48 Mitem/s  │ 8.833 Mitem/s │ 8.784 Mitem/s │         │
+
+//
+
+#[thread_local]
+static WORLDS: RefCell<BTreeMap<u16, Broadcaster>> = RefCell::new(BTreeMap::new());
+
+// Register a `fibonacci` function and benchmark it over multiple cases.
+#[divan::bench(
+    args = LENS,
+)]
+fn player_render_distance_32(bencher: Bencher, len: u16) {
+    const PLAYER_COUNT: usize = 10_000;
+    const PLAYER_VIEW_DISTANCE: u16 = 32;
+
+    let mut worlds = WORLDS.borrow_mut();
+    let world = worlds.entry(len).or_insert_with(|| generate_world(len));
+
+    // let mut world = generate_world(len);
+
+    bencher.counter(PLAYER_COUNT).bench_local(move || {
+        for _ in 0..PLAYER_COUNT {
+            let start_x = rand::random::<u16>() % (len - PLAYER_VIEW_DISTANCE * 2);
+            let end_x = start_x + PLAYER_VIEW_DISTANCE * 2;
+
+            let start_y = rand::random::<u16>() % (len - PLAYER_VIEW_DISTANCE * 2);
+            let end_y = start_y + PLAYER_VIEW_DISTANCE * 2;
+
+            let res = world.data_range(start_x..end_x, start_y..end_y);
+            for elem in res {
+                black_box(elem);
+            }
+        }
+    });
+}