1#[cfg(feature = "plugins")]
2use crate::plugin::PluginMgr;
3#[cfg(feature = "plugins")]
4use crate::plugin::memory_manager::EcsWorld;
5use crate::{BuildArea, NoDurabilityArea};
6#[cfg(feature = "plugins")]
7use common::uid::IdMaps;
8use common::{
9 calendar::Calendar,
10 comp,
11 event::{EventBus, LocalEvent},
12 interaction,
13 link::Is,
14 mounting::{Mount, Rider, VolumeRider, VolumeRiders},
15 outcome::Outcome,
16 resources::{
17 DeltaTime, EntitiesDiedLastTick, GameMode, PlayerEntity, PlayerPhysicsSettings,
18 ProgramTime, Time, TimeOfDay, TimeScale,
19 },
20 shared_server_config::ServerConstants,
21 slowjob::SlowJobPool,
22 terrain::{Block, MapSizeLg, TerrainChunk, TerrainGrid},
23 tether,
24 time::DayPeriod,
25 trade::Trades,
26 vol::{ReadVol, WriteVol},
27 weather::{Weather, WeatherGrid},
28};
29use common_base::{prof_span, span};
30use common_ecs::{PhysicsMetrics, SysMetrics};
31use common_net::sync::{WorldSyncExt, interpolation as sync_interp};
32use core::{convert::identity, time::Duration};
33use hashbrown::{HashMap, HashSet};
34use rayon::{ThreadPool, ThreadPoolBuilder};
35use specs::{
36 Component, DispatcherBuilder, Entity as EcsEntity, WorldExt,
37 prelude::Resource,
38 shred::{Fetch, FetchMut, SendDispatcher},
39 storage::{MaskedStorage as EcsMaskedStorage, Storage as EcsStorage},
40};
41use std::{sync::Arc, time::Instant};
42use timer_queue::TimerQueue;
43use vek::*;
44
45const MAX_DELTA_TIME: f32 = 1.0;
51const SECONDS_TO_MILLISECONDS: f64 = 1000.0;
53
54#[derive(Default)]
55pub struct BlockChange {
56 blocks: HashMap<Vec3<i32>, Block>,
57}
58
59impl BlockChange {
60 pub fn set(&mut self, pos: Vec3<i32>, block: Block) { self.blocks.insert(pos, block); }
61
62 pub fn try_set(&mut self, pos: Vec3<i32>, block: Block) -> Option<()> {
63 if !self.blocks.contains_key(&pos) {
64 self.blocks.insert(pos, block);
65 Some(())
66 } else {
67 None
68 }
69 }
70
71 pub fn can_set_block(&self, pos: Vec3<i32>) -> bool { !self.blocks.contains_key(&pos) }
74
75 pub fn clear(&mut self) { self.blocks.clear(); }
76}
77
78#[derive(Default)]
79pub struct ScheduledBlockChange {
80 changes: TimerQueue<HashMap<Vec3<i32>, Block>>,
81 outcomes: TimerQueue<HashMap<Vec3<i32>, Block>>,
82 last_poll_time: u64,
83}
84impl ScheduledBlockChange {
85 pub fn set(&mut self, pos: Vec3<i32>, block: Block, replace_time: f64) {
86 let timer = self.changes.insert(
87 (replace_time * SECONDS_TO_MILLISECONDS) as u64,
88 HashMap::new(),
89 );
90 self.changes.get_mut(timer).insert(pos, block);
91 }
92
93 pub fn outcome_set(&mut self, pos: Vec3<i32>, block: Block, replace_time: f64) {
94 let outcome_timer = self.outcomes.insert(
95 (replace_time * SECONDS_TO_MILLISECONDS) as u64,
96 HashMap::new(),
97 );
98 self.outcomes.get_mut(outcome_timer).insert(pos, block);
99 }
100}
101
102#[derive(Default)]
103pub struct TerrainChanges {
104 pub new_chunks: HashSet<Vec2<i32>>,
105 pub modified_chunks: HashSet<Vec2<i32>>,
106 pub removed_chunks: HashSet<Vec2<i32>>,
107 pub modified_blocks: HashMap<Vec3<i32>, Block>,
108}
109
110impl TerrainChanges {
111 pub fn clear(&mut self) {
112 self.new_chunks.clear();
113 self.modified_chunks.clear();
114 self.removed_chunks.clear();
115 }
116}
117
118#[derive(Clone)]
119pub struct BlockDiff {
120 pub wpos: Vec3<i32>,
121 pub old: Block,
122 pub new: Block,
123}
124
125pub struct State {
129 ecs: specs::World,
130 thread_pool: Arc<ThreadPool>,
132 dispatcher: SendDispatcher<'static>,
133}
134
135pub type Pools = Arc<ThreadPool>;
136
137impl State {
138 pub fn pools(game_mode: GameMode) -> Pools {
139 let thread_name_infix = match game_mode {
140 GameMode::Server => "s",
141 GameMode::Client => "c",
142 GameMode::Singleplayer => "sp",
143 };
144
145 Arc::new(
146 ThreadPoolBuilder::new()
147 .num_threads(num_cpus::get().max(common::consts::MIN_RECOMMENDED_RAYON_THREADS))
148 .thread_name(move |i| format!("rayon-{}-{}", thread_name_infix, i))
149 .build()
150 .unwrap(),
151 )
152 }
153
154 pub fn client(
156 pools: Pools,
157 map_size_lg: MapSizeLg,
158 default_chunk: Arc<TerrainChunk>,
159 add_systems: impl Fn(&mut DispatcherBuilder),
160 #[cfg(feature = "plugins")] plugin_mgr: PluginMgr,
161 ) -> Self {
162 Self::new(
163 GameMode::Client,
164 pools,
165 map_size_lg,
166 default_chunk,
167 add_systems,
168 #[cfg(feature = "plugins")]
169 plugin_mgr,
170 )
171 }
172
173 pub fn server(
175 pools: Pools,
176 map_size_lg: MapSizeLg,
177 default_chunk: Arc<TerrainChunk>,
178 add_systems: impl Fn(&mut DispatcherBuilder),
179 #[cfg(feature = "plugins")] plugin_mgr: PluginMgr,
180 ) -> Self {
181 Self::new(
182 GameMode::Server,
183 pools,
184 map_size_lg,
185 default_chunk,
186 add_systems,
187 #[cfg(feature = "plugins")]
188 plugin_mgr,
189 )
190 }
191
192 pub fn new(
193 game_mode: GameMode,
194 pools: Pools,
195 map_size_lg: MapSizeLg,
196 default_chunk: Arc<TerrainChunk>,
197 add_systems: impl Fn(&mut DispatcherBuilder),
198 #[cfg(feature = "plugins")] plugin_mgr: PluginMgr,
199 ) -> Self {
200 prof_span!(guard, "create dispatcher");
201 let mut dispatch_builder =
202 DispatcherBuilder::<'static, 'static>::new().with_pool(Arc::clone(&pools));
203 add_systems(&mut dispatch_builder);
205 let dispatcher = dispatch_builder
206 .build()
207 .try_into_sendable()
208 .unwrap_or_else(|_| panic!("Thread local systems not allowed"));
209 drop(guard);
210
211 Self {
212 ecs: Self::setup_ecs_world(
213 game_mode,
214 Arc::clone(&pools),
215 map_size_lg,
216 default_chunk,
217 #[cfg(feature = "plugins")]
218 plugin_mgr,
219 ),
220 thread_pool: pools,
221 dispatcher,
222 }
223 }
224
225 fn setup_ecs_world(
229 game_mode: GameMode,
230 thread_pool: Arc<ThreadPool>,
231 map_size_lg: MapSizeLg,
232 default_chunk: Arc<TerrainChunk>,
233 #[cfg(feature = "plugins")] mut plugin_mgr: PluginMgr,
234 ) -> specs::World {
235 prof_span!("State::setup_ecs_world");
236 let mut ecs = specs::World::new();
237 ecs.register_sync_marker();
239 ecs.register::<comp::Body>();
241 ecs.register::<comp::Hardcore>();
242 ecs.register::<comp::body::parts::Heads>();
243 ecs.register::<comp::Player>();
244 ecs.register::<comp::Stats>();
245 ecs.register::<comp::SkillSet>();
246 ecs.register::<comp::ActiveAbilities>();
247 ecs.register::<comp::Buffs>();
248 ecs.register::<comp::Auras>();
249 ecs.register::<comp::EnteredAuras>();
250 ecs.register::<comp::Energy>();
251 ecs.register::<comp::Combo>();
252 ecs.register::<comp::Health>();
253 ecs.register::<comp::Poise>();
254 ecs.register::<comp::CanBuild>();
255 ecs.register::<comp::LightEmitter>();
256 ecs.register::<comp::PickupItem>();
257 ecs.register::<comp::ThrownItem>();
258 ecs.register::<comp::Scale>();
259 ecs.register::<Is<Mount>>();
260 ecs.register::<Is<Rider>>();
261 ecs.register::<Is<VolumeRider>>();
262 ecs.register::<Is<tether::Leader>>();
263 ecs.register::<Is<tether::Follower>>();
264 ecs.register::<Is<interaction::Interactor>>();
265 ecs.register::<interaction::Interactors>();
266 ecs.register::<comp::Mass>();
267 ecs.register::<comp::Density>();
268 ecs.register::<comp::Collider>();
269 ecs.register::<comp::Sticky>();
270 ecs.register::<comp::Immovable>();
271 ecs.register::<comp::CharacterState>();
272 ecs.register::<comp::CharacterActivity>();
273 ecs.register::<comp::Object>();
274 ecs.register::<comp::Group>();
275 ecs.register::<comp::Shockwave>();
276 ecs.register::<comp::ShockwaveHitEntities>();
277 ecs.register::<comp::Beam>();
278 ecs.register::<comp::Alignment>();
279 ecs.register::<comp::LootOwner>();
280 ecs.register::<comp::Admin>();
281 ecs.register::<comp::Stance>();
282 ecs.register::<comp::Teleporting>();
283
284 ecs.register::<comp::Controller>();
286
287 ecs.register::<comp::PhysicsState>();
289
290 ecs.register::<comp::Pos>();
292 ecs.register::<comp::Vel>();
293 ecs.register::<comp::Ori>();
294 ecs.register::<comp::Inventory>();
295
296 ecs.register::<comp::PreviousPhysCache>();
298 ecs.register::<comp::PosVelOriDefer>();
299
300 ecs.register::<comp::LightAnimation>();
303 ecs.register::<sync_interp::InterpBuffer<comp::Pos>>();
304 ecs.register::<sync_interp::InterpBuffer<comp::Vel>>();
305 ecs.register::<sync_interp::InterpBuffer<comp::Ori>>();
306
307 ecs.register::<comp::Last<comp::Pos>>();
310 ecs.register::<comp::Last<comp::Vel>>();
311 ecs.register::<comp::Last<comp::Ori>>();
312 ecs.register::<comp::Agent>();
313 ecs.register::<comp::WaypointArea>();
314 ecs.register::<comp::ForceUpdate>();
315 ecs.register::<comp::InventoryUpdate>();
316 ecs.register::<comp::Waypoint>();
317 ecs.register::<comp::MapMarker>();
318 ecs.register::<comp::Projectile>();
319 ecs.register::<comp::Melee>();
320 ecs.register::<comp::ItemDrops>();
321 ecs.register::<comp::ChatMode>();
322 ecs.register::<comp::Faction>();
323 ecs.register::<comp::invite::Invite>();
324 ecs.register::<comp::invite::PendingInvites>();
325 ecs.register::<VolumeRiders>();
326 ecs.register::<common::combat::DeathEffects>();
327 ecs.register::<common::combat::RiderEffects>();
328
329 ecs.insert(TimeOfDay(0.0));
331 ecs.insert(Calendar::default());
332 ecs.insert(WeatherGrid::new(Vec2::zero()));
333 ecs.insert(Time(0.0));
334 ecs.insert(ProgramTime(0.0));
335 ecs.insert(TimeScale(1.0));
336
337 ecs.insert(DeltaTime(0.0));
339 ecs.insert(PlayerEntity(None));
340 ecs.insert(TerrainGrid::new(map_size_lg, default_chunk).unwrap());
341 ecs.insert(BlockChange::default());
342 ecs.insert(ScheduledBlockChange::default());
343 ecs.insert(crate::special_areas::AreasContainer::<BuildArea>::default());
344 ecs.insert(crate::special_areas::AreasContainer::<NoDurabilityArea>::default());
345 ecs.insert(TerrainChanges::default());
346 ecs.insert(EventBus::<LocalEvent>::default());
347 ecs.insert(game_mode);
348 ecs.insert(EventBus::<Outcome>::default());
349 ecs.insert(common::CachedSpatialGrid::default());
350 ecs.insert(EntitiesDiedLastTick::default());
351
352 let num_cpu = num_cpus::get() as u64;
353 let slow_limit = (num_cpu / 2 + num_cpu / 4).max(1);
354 tracing::trace!(?slow_limit, "Slow Thread limit");
355 ecs.insert(SlowJobPool::new(slow_limit, 10_000, thread_pool));
356
357 ecs.insert(comp::group::GroupManager::default());
359 ecs.insert(SysMetrics::default());
360 ecs.insert(PhysicsMetrics::default());
361 ecs.insert(Trades::default());
362 ecs.insert(PlayerPhysicsSettings::default());
363 ecs.insert(VolumeRiders::default());
364
365 #[cfg(feature = "plugins")]
367 ecs.insert({
368 let ecs_world = EcsWorld {
369 entities: &ecs.entities(),
370 health: ecs.read_component().into(),
371 uid: ecs.read_component().into(),
372 id_maps: &ecs.read_resource::<IdMaps>().into(),
373 player: ecs.read_component().into(),
374 };
375 if let Err(e) = plugin_mgr.load_event(&ecs_world, game_mode) {
376 tracing::debug!(?e, "Failed to run plugin init");
377 tracing::info!("Plugins disabled, enable debug logging for more information.");
378 PluginMgr::default()
379 } else {
380 plugin_mgr
381 }
382 });
383
384 ecs
385 }
386
387 #[must_use]
389 pub fn with_component<T: Component>(mut self) -> Self
390 where
391 <T as Component>::Storage: Default,
392 {
393 self.ecs.register::<T>();
394 self
395 }
396
397 pub fn write_component_ignore_entity_dead<C: Component>(
406 &mut self,
407 entity: EcsEntity,
408 comp: C,
409 ) -> Option<C> {
410 self.ecs
411 .write_storage()
412 .insert(entity, comp)
413 .ok()
414 .and_then(identity)
415 }
416
417 pub fn delete_component<C: Component>(&mut self, entity: EcsEntity) -> Option<C> {
419 self.ecs.write_storage().remove(entity)
420 }
421
422 pub fn read_component_cloned<C: Component + Clone>(&self, entity: EcsEntity) -> Option<C> {
424 self.ecs.read_storage().get(entity).cloned()
425 }
426
427 pub fn read_component_copied<C: Component + Copy>(&self, entity: EcsEntity) -> Option<C> {
429 self.ecs.read_storage().get(entity).copied()
430 }
431
432 pub fn emit_event_now<E>(&self, event: E)
435 where
436 EventBus<E>: Resource,
437 {
438 self.ecs.write_resource::<EventBus<E>>().emit_now(event)
439 }
440
441 pub fn mut_resource<R: Resource>(&mut self) -> &mut R {
446 self.ecs.get_mut::<R>().expect(
447 "Tried to fetch an invalid resource even though all our resources should be known at \
448 compile time.",
449 )
450 }
451
452 pub fn read_storage<C: Component>(&self) -> EcsStorage<C, Fetch<EcsMaskedStorage<C>>> {
454 self.ecs.read_storage::<C>()
455 }
456
457 pub fn ecs(&self) -> &specs::World { &self.ecs }
459
460 pub fn ecs_mut(&mut self) -> &mut specs::World { &mut self.ecs }
462
463 pub fn thread_pool(&self) -> &Arc<ThreadPool> { &self.thread_pool }
464
465 pub fn terrain_changes(&self) -> Fetch<TerrainChanges> { self.ecs.read_resource() }
469
470 pub fn weather_grid(&self) -> Fetch<WeatherGrid> { self.ecs.read_resource() }
472
473 pub fn weather_grid_mut(&mut self) -> FetchMut<WeatherGrid> { self.ecs.write_resource() }
475
476 pub fn weather_at(&self, pos: Vec2<f32>) -> Weather {
478 self.weather_grid().get_interpolated(pos)
479 }
480
481 pub fn max_weather_near(&self, pos: Vec2<f32>) -> Weather {
483 self.weather_grid().get_max_near(pos)
484 }
485
486 pub fn get_time_of_day(&self) -> f64 { self.ecs.read_resource::<TimeOfDay>().0 }
491
492 pub fn get_day_period(&self) -> DayPeriod { self.get_time_of_day().into() }
494
495 pub fn get_time(&self) -> f64 { self.ecs.read_resource::<Time>().0 }
499
500 pub fn get_program_time(&self) -> f64 { self.ecs.read_resource::<ProgramTime>().0 }
504
505 pub fn get_delta_time(&self) -> f32 { self.ecs.read_resource::<DeltaTime>().0 }
507
508 pub fn terrain(&self) -> Fetch<TerrainGrid> { self.ecs.read_resource() }
510
511 pub fn slow_job_pool(&self) -> Fetch<SlowJobPool> { self.ecs.read_resource() }
513
514 pub fn terrain_mut(&self) -> FetchMut<TerrainGrid> { self.ecs.write_resource() }
516
517 pub fn get_block(&self, pos: Vec3<i32>) -> Option<Block> {
519 self.terrain().get(pos).ok().copied()
520 }
521
522 pub fn set_block(&self, pos: Vec3<i32>, block: Block) {
524 self.ecs.write_resource::<BlockChange>().set(pos, block);
525 }
526
527 pub fn schedule_set_block(
530 &self,
531 pos: Vec3<i32>,
532 block: Block,
533 sprite_block: Block,
534 replace_time: f64,
535 ) {
536 self.ecs
537 .write_resource::<ScheduledBlockChange>()
538 .set(pos, block, replace_time);
539 self.ecs
540 .write_resource::<ScheduledBlockChange>()
541 .outcome_set(pos, sprite_block, replace_time);
542 }
543
544 pub fn can_set_block(&self, pos: Vec3<i32>) -> bool {
547 self.ecs.read_resource::<BlockChange>().can_set_block(pos)
548 }
549
550 pub fn clear_terrain(&mut self) -> usize {
552 let removed_chunks = &mut self.ecs.write_resource::<TerrainChanges>().removed_chunks;
553
554 self.terrain_mut()
555 .drain()
556 .map(|(key, _)| {
557 removed_chunks.insert(key);
558 })
559 .count()
560 }
561
562 pub fn insert_chunk(&mut self, key: Vec2<i32>, chunk: Arc<TerrainChunk>) {
564 if self
565 .ecs
566 .write_resource::<TerrainGrid>()
567 .insert(key, chunk)
568 .is_some()
569 {
570 self.ecs
571 .write_resource::<TerrainChanges>()
572 .modified_chunks
573 .insert(key);
574 } else {
575 self.ecs
576 .write_resource::<TerrainChanges>()
577 .new_chunks
578 .insert(key);
579 }
580 }
581
582 pub fn remove_chunk(&mut self, key: Vec2<i32>) -> bool {
585 if self
586 .ecs
587 .write_resource::<TerrainGrid>()
588 .remove(key)
589 .is_some()
590 {
591 self.ecs
592 .write_resource::<TerrainChanges>()
593 .removed_chunks
594 .insert(key);
595
596 true
597 } else {
598 false
599 }
600 }
601
602 pub fn apply_terrain_changes(&self, block_update: impl FnMut(&specs::World, Vec<BlockDiff>)) {
604 self.apply_terrain_changes_internal(false, block_update);
605 }
606
607 fn apply_terrain_changes_internal(
615 &self,
616 during_tick: bool,
617 mut block_update: impl FnMut(&specs::World, Vec<BlockDiff>),
618 ) {
619 span!(
620 _guard,
621 "apply_terrain_changes",
622 "State::apply_terrain_changes"
623 );
624 let mut terrain = self.ecs.write_resource::<TerrainGrid>();
625 let mut modified_blocks =
626 std::mem::take(&mut self.ecs.write_resource::<BlockChange>().blocks);
627
628 let mut scheduled_changes = self.ecs.write_resource::<ScheduledBlockChange>();
629 let current_time: f64 = self.ecs.read_resource::<Time>().0 * SECONDS_TO_MILLISECONDS;
630 let current_time = current_time as u64;
631 if scheduled_changes.last_poll_time < current_time {
636 scheduled_changes.last_poll_time = current_time;
637 while let Some(changes) = scheduled_changes.changes.poll(current_time) {
638 modified_blocks.extend(changes.iter());
639 }
640 let outcome = self.ecs.read_resource::<EventBus<Outcome>>();
641 while let Some(outcomes) = scheduled_changes.outcomes.poll(current_time) {
642 for (pos, block) in outcomes.into_iter() {
643 if let Some(sprite) = block.get_sprite() {
644 outcome.emit_now(Outcome::SpriteDelete { pos, sprite });
645 }
646 }
647 }
648 }
649 let mut updated_blocks = Vec::with_capacity(modified_blocks.len());
652 modified_blocks.retain(|wpos, new| {
653 let res = terrain.map(*wpos, |old| {
654 updated_blocks.push(BlockDiff {
655 wpos: *wpos,
656 old,
657 new: *new,
658 });
659 *new
660 });
661 if let (&Ok(old), true) = (&res, during_tick) {
662 *new = old;
667 }
668 res.is_ok()
669 });
670
671 if !updated_blocks.is_empty() {
672 block_update(&self.ecs, updated_blocks);
673 }
674
675 self.ecs.write_resource::<TerrainChanges>().modified_blocks = modified_blocks;
676 }
677
678 pub fn tick(
680 &mut self,
681 dt: Duration,
682 update_terrain: bool,
683 mut metrics: Option<&mut StateTickMetrics>,
684 server_constants: &ServerConstants,
685 block_update: impl FnMut(&specs::World, Vec<BlockDiff>),
686 ) {
687 span!(_guard, "tick", "State::tick");
688
689 macro_rules! section_span {
691 ($guard:ident, $label:literal) => {
692 span!(span_guard, $label);
693 let metrics_guard = metrics.as_mut().map(|m| MetricsGuard::new($label, m));
694 let $guard = (span_guard, metrics_guard);
695 };
696 }
697
698 let time_scale = self.ecs.read_resource::<TimeScale>().0;
700 self.ecs.write_resource::<TimeOfDay>().0 +=
701 dt.as_secs_f64() * server_constants.day_cycle_coefficient * time_scale;
702 self.ecs.write_resource::<Time>().0 += dt.as_secs_f64() * time_scale;
703 self.ecs.write_resource::<ProgramTime>().0 += dt.as_secs_f64();
704
705 self.ecs.write_resource::<DeltaTime>().0 =
709 (dt.as_secs_f32() * time_scale as f32).min(MAX_DELTA_TIME);
710
711 section_span!(guard, "run systems");
712 self.dispatcher.dispatch(&self.ecs);
714 drop(guard);
715
716 self.maintain_ecs();
717
718 if update_terrain {
719 self.apply_terrain_changes_internal(true, block_update);
720 }
721
722 section_span!(guard, "process local events");
724
725 let outcomes = self.ecs.read_resource::<EventBus<Outcome>>();
726 let mut outcomes_emitter = outcomes.emitter();
727
728 let events = self.ecs.read_resource::<EventBus<LocalEvent>>().recv_all();
729 for event in events {
730 let mut velocities = self.ecs.write_storage::<comp::Vel>();
731 let physics = self.ecs.read_storage::<comp::PhysicsState>();
732 match event {
733 LocalEvent::Jump(entity, impulse) => {
734 if let Some(vel) = velocities.get_mut(entity) {
735 vel.0.z = impulse + physics.get(entity).map_or(0.0, |ps| ps.ground_vel.z);
736 }
737 },
738 LocalEvent::ApplyImpulse { entity, impulse } => {
739 if let Some(vel) = velocities.get_mut(entity) {
740 vel.0 = impulse;
741 }
742 },
743 LocalEvent::Boost {
744 entity,
745 vel: extra_vel,
746 } => {
747 if let Some(vel) = velocities.get_mut(entity) {
748 vel.0 += extra_vel;
749 }
750 },
751 LocalEvent::CreateOutcome(outcome) => {
752 outcomes_emitter.emit(outcome);
753 },
754 }
755 }
756 drop(guard);
757 }
758
759 pub fn maintain_ecs(&mut self) {
760 span!(_guard, "maintain ecs");
761 self.ecs.maintain();
762 }
763
764 pub fn cleanup(&mut self) {
766 span!(_guard, "cleanup", "State::cleanup");
767 self.ecs.write_resource::<TerrainChanges>().clear();
769 }
770}
771
772#[derive(Default)]
774pub struct StateTickMetrics {
775 pub timings: Vec<(&'static str, Duration)>,
776}
777
778impl StateTickMetrics {
779 fn add(&mut self, label: &'static str, dur: Duration) {
780 debug_assert!(
782 self.timings.iter().all(|(l, _)| *l != label),
783 "Duplicate label in state tick metrics {label}"
784 );
785 self.timings.push((label, dur));
786 }
787}
788
789struct MetricsGuard<'a> {
790 start: Instant,
791 label: &'static str,
792 metrics: &'a mut StateTickMetrics,
793}
794
795impl<'a> MetricsGuard<'a> {
796 fn new(label: &'static str, metrics: &'a mut StateTickMetrics) -> Self {
797 Self {
798 start: Instant::now(),
799 label,
800 metrics,
801 }
802 }
803}
804
805impl Drop for MetricsGuard<'_> {
806 fn drop(&mut self) { self.metrics.add(self.label, self.start.elapsed()); }
807}