dscale 0.5.2

A fast & deterministic simulation framework for benchmarking and testing distributed systems
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

use std::{any::Any, sync::Arc};

fn static_zst<T: Message + 'static>() -> MessagePtr {
    let reference: &'static T = unsafe { &*std::ptr::NonNull::<T>::dangling().as_ptr() };
    MessagePtr::Static(reference)
}

/// Trait for values that can be sent between simulated processes.
///
/// The optional [`Message::virtual_size`] method controls bandwidth simulation.
/// If bandwidth is unbounded, the default (zero) is fine.
pub trait Message: Any + Send + Sync {
    /// Size in bytes used for bandwidth simulation.
    /// Can exceed the real memory footprint to model heavy payloads.
    /// Defaults to 0 (no bandwidth cost).
    fn virtual_size(&self) -> usize {
        usize::default()
    }
}

/// Reference-counted wrapper around a [`Message`].
///
/// Provides type-safe downcasting to recover the concrete message type.
/// For zero-sized messages, avoids heap allocation entirely.
#[derive(Clone)]
pub enum MessagePtr {
    Shared(Arc<dyn Message>),
    Static(&'static dyn Message),
}

impl MessagePtr {
    /// Creates a new `MessagePtr`. For zero-sized types this avoids heap allocation
    /// by using a static reference — ZSTs have no data, only the vtable pointer matters.
    pub fn new<T: Message + 'static>(msg: T) -> Self {
        if std::mem::size_of::<T>() == 0 {
            // Each monomorphization of this function gets its own static instance.
            // ZSTs have no data, so the static is just a vtable anchor — zero heap allocation.
            static_zst::<T>()
        } else {
            MessagePtr::Shared(Arc::new(msg))
        }
    }

    fn as_dyn(&self) -> &dyn Message {
        match self {
            MessagePtr::Shared(arc) => &**arc,
            MessagePtr::Static(r) => *r,
        }
    }

    /// Attempts to downcast to `T`. Returns `None` if the type does not match.
    pub fn try_as_type<T: 'static>(&self) -> Option<&T> {
        (self.as_dyn() as &dyn Any).downcast_ref::<T>()
    }

    /// Returns `true` if the contained message is of type `T`.
    pub fn is<T: 'static>(&self) -> bool {
        self.try_as_type::<T>().is_some()
    }

    /// Downcasts to `T`, panicking if the type does not match.
    pub fn as_type<T: 'static>(&self) -> &T {
        self.try_as_type::<T>().expect("Failed as_type")
    }

    /// Returns the virtual size of the message for bandwidth simulation.
    pub fn virtual_size(&self) -> usize {
        self.as_dyn().virtual_size()
    }
}