wasmtime 37.0.2 → 38.0.4

data/ext/cargo-vendor/fxprof-processed-profile-0.8.1/src/reference_timestamp.rs

@@ -0,0 +1,44 @@
+use std::time::{Duration, SystemTime, UNIX_EPOCH};
+
+use serde::ser::{Serialize, Serializer};
+
+/// A timestamp which anchors the profile in absolute time.
+///
+/// In the profile JSON, this uses a UNIX timestamp.
+///
+/// All timestamps in the profile are relative to this reference timestamp.
+#[derive(Debug, Clone, Copy, PartialOrd, PartialEq)]
+pub struct ReferenceTimestamp {
+    ms_since_unix_epoch: f64,
+}
+
+impl ReferenceTimestamp {
+    /// Create a reference timestamp from a [`Duration`] since the UNIX epoch.
+    pub fn from_duration_since_unix_epoch(duration: Duration) -> Self {
+        Self::from_millis_since_unix_epoch(duration.as_secs_f64() * 1000.0)
+    }
+
+    /// Create a reference timestamp from milliseconds since the UNIX epoch.
+    pub fn from_millis_since_unix_epoch(ms_since_unix_epoch: f64) -> Self {
+        Self {
+            ms_since_unix_epoch,
+        }
+    }
+
+    /// Create a reference timestamp from a [`SystemTime`].
+    pub fn from_system_time(system_time: SystemTime) -> Self {
+        Self::from_duration_since_unix_epoch(system_time.duration_since(UNIX_EPOCH).unwrap())
+    }
+}
+
+impl From<SystemTime> for ReferenceTimestamp {
+    fn from(system_time: SystemTime) -> Self {
+        Self::from_system_time(system_time)
+    }
+}
+
+impl Serialize for ReferenceTimestamp {
+    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        self.ms_since_unix_epoch.serialize(serializer)
+    }
+}

data/ext/cargo-vendor/fxprof-processed-profile-0.8.1/src/resource_table.rs

@@ -0,0 +1,62 @@
+use serde::ser::{Serialize, SerializeMap, Serializer};
+
+use crate::fast_hash_map::FastHashMap;
+use crate::global_lib_table::{GlobalLibIndex, GlobalLibTable};
+use crate::serialization_helpers::SerializableSingleValueColumn;
+use crate::thread_string_table::{ThreadInternalStringIndex, ThreadStringTable};
+
+#[derive(Debug, Clone, Default)]
+pub struct ResourceTable {
+    resource_libs: Vec<GlobalLibIndex>,
+    resource_names: Vec<ThreadInternalStringIndex>,
+    lib_to_resource: FastHashMap<GlobalLibIndex, ResourceIndex>,
+}
+
+impl ResourceTable {
+    pub fn new() -> Self {
+        Default::default()
+    }
+
+    pub fn resource_for_lib(
+        &mut self,
+        lib_index: GlobalLibIndex,
+        global_libs: &GlobalLibTable,
+        thread_string_table: &mut ThreadStringTable,
+    ) -> ResourceIndex {
+        let resource_libs = &mut self.resource_libs;
+        let resource_names = &mut self.resource_names;
+        *self.lib_to_resource.entry(lib_index).or_insert_with(|| {
+            let resource = ResourceIndex(resource_libs.len() as u32);
+            let lib_name = &global_libs.get_lib(lib_index).unwrap().name;
+            resource_libs.push(lib_index);
+            resource_names.push(thread_string_table.index_for_string(lib_name));
+            resource
+        })
+    }
+}
+
+impl Serialize for ResourceTable {
+    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        const RESOURCE_TYPE_LIB: u32 = 1;
+        let len = self.resource_libs.len();
+        let mut map = serializer.serialize_map(None)?;
+        map.serialize_entry("length", &len)?;
+        map.serialize_entry("lib", &self.resource_libs)?;
+        map.serialize_entry("name", &self.resource_names)?;
+        map.serialize_entry("host", &SerializableSingleValueColumn((), len))?;
+        map.serialize_entry(
+            "type",
+            &SerializableSingleValueColumn(RESOURCE_TYPE_LIB, len),
+        )?;
+        map.end()
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialOrd, Ord, PartialEq, Eq, Hash)]
+pub struct ResourceIndex(u32);
+
+impl Serialize for ResourceIndex {
+    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        serializer.serialize_u32(self.0)
+    }
+}

data/ext/cargo-vendor/fxprof-processed-profile-0.8.1/src/sample_table.rs

@@ -0,0 +1,335 @@
+use std::fmt::{Display, Formatter};
+
+use serde::ser::{Serialize, SerializeMap, Serializer};
+
+use crate::cpu_delta::CpuDelta;
+use crate::serialization_helpers::{SerializableSingleValueColumn, SliceWithPermutation};
+use crate::timestamp::{
+    SerializableTimestampSliceAsDeltas, SerializableTimestampSliceAsDeltasWithPermutation,
+    Timestamp,
+};
+
+/// The sample table contains stacks with timestamps and some extra information.
+///
+/// In the most common case, this is used for time-based sampling: At a fixed but
+/// configurable rate, a profiler samples the current stack of each thread and records
+/// it in the profile.
+#[derive(Debug, Clone)]
+pub struct SampleTable {
+    sample_weight_type: WeightType,
+    sample_weights: Vec<i32>,
+    sample_timestamps: Vec<Timestamp>,
+    /// An index into the thread's stack table for each sample. `None` means the empty stack.
+    sample_stack_indexes: Vec<Option<usize>>,
+    /// CPU usage delta since the previous sample for this thread, for each sample.
+    sample_cpu_deltas: Vec<CpuDelta>,
+    is_sorted_by_time: bool,
+    last_sample_timestamp: Timestamp,
+}
+
+/// Specifies the meaning of the "weight" value of a thread's samples.
+#[derive(Debug, Clone)]
+pub enum WeightType {
+    /// The weight is an integer multiplier. For example, "this stack was
+    /// observed n times when sampling at the specified interval."
+    ///
+    /// This affects the total + self score of each call node in the call tree,
+    /// and the order in the tree because the tree is ordered from large "totals"
+    /// to small "totals".
+    /// It also affects the width of the sample's stack's box in the flame graph.
+    Samples,
+    /// The weight is a duration in (fractional) milliseconds.
+    ///
+    /// Note that, since [`Profile::add_sample`](crate::Profile::add_sample) currently
+    /// only accepts integer weight values, the usefulness of `TracingMs` is
+    /// currently limited.
+    TracingMs,
+    /// The weight of each sample is a value in bytes.
+    ///
+    /// This can be used for profiles with allocation stacks. It can also be used
+    /// for "size" profiles which give a bytes breakdown of the contents of a file.
+    Bytes,
+}
+
+impl Display for WeightType {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        match self {
+            WeightType::Samples => write!(f, "samples"),
+            WeightType::TracingMs => write!(f, "tracing-ms"),
+            WeightType::Bytes => write!(f, "bytes"),
+        }
+    }
+}
+
+impl Serialize for WeightType {
+    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        match self {
+            WeightType::Samples => serializer.serialize_str("samples"),
+            WeightType::TracingMs => serializer.serialize_str("tracing-ms"),
+            WeightType::Bytes => serializer.serialize_str("bytes"),
+        }
+    }
+}
+
+impl SampleTable {
+    pub fn new() -> Self {
+        Self {
+            sample_weight_type: WeightType::Samples,
+            sample_weights: Vec::new(),
+            sample_timestamps: Vec::new(),
+            sample_stack_indexes: Vec::new(),
+            sample_cpu_deltas: Vec::new(),
+            is_sorted_by_time: true,
+            last_sample_timestamp: Timestamp::from_nanos_since_reference(0),
+        }
+    }
+
+    pub fn add_sample(
+        &mut self,
+        timestamp: Timestamp,
+        stack_index: Option<usize>,
+        cpu_delta: CpuDelta,
+        weight: i32,
+    ) {
+        self.sample_weights.push(weight);
+        self.sample_timestamps.push(timestamp);
+        self.sample_stack_indexes.push(stack_index);
+        self.sample_cpu_deltas.push(cpu_delta);
+        if timestamp < self.last_sample_timestamp {
+            self.is_sorted_by_time = false;
+        }
+        self.last_sample_timestamp = timestamp;
+    }
+
+    pub fn set_weight_type(&mut self, t: WeightType) {
+        self.sample_weight_type = t;
+    }
+
+    pub fn modify_last_sample(&mut self, timestamp: Timestamp, weight: i32) {
+        *self.sample_weights.last_mut().unwrap() += weight;
+        *self.sample_timestamps.last_mut().unwrap() = timestamp;
+    }
+}
+
+impl Serialize for SampleTable {
+    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        let len = self.sample_timestamps.len();
+        let mut map = serializer.serialize_map(None)?;
+        map.serialize_entry("length", &len)?;
+        map.serialize_entry("weightType", &self.sample_weight_type.to_string())?;
+
+        if self.is_sorted_by_time {
+            map.serialize_entry("stack", &self.sample_stack_indexes)?;
+            map.serialize_entry(
+                "timeDeltas",
+                &SerializableTimestampSliceAsDeltas(&self.sample_timestamps),
+            )?;
+            map.serialize_entry("weight", &self.sample_weights)?;
+            map.serialize_entry("threadCPUDelta", &self.sample_cpu_deltas)?;
+        } else {
+            let mut indexes: Vec<usize> = (0..self.sample_timestamps.len()).collect();
+            indexes.sort_unstable_by_key(|index| self.sample_timestamps[*index]);
+            map.serialize_entry(
+                "stack",
+                &SliceWithPermutation(&self.sample_stack_indexes, &indexes),
+            )?;
+            map.serialize_entry(
+                "timeDeltas",
+                &SerializableTimestampSliceAsDeltasWithPermutation(
+                    &self.sample_timestamps,
+                    &indexes,
+                ),
+            )?;
+            map.serialize_entry(
+                "weight",
+                &SliceWithPermutation(&self.sample_weights, &indexes),
+            )?;
+            map.serialize_entry(
+                "threadCPUDelta",
+                &SliceWithPermutation(&self.sample_cpu_deltas, &indexes),
+            )?;
+        }
+        map.end()
+    }
+}
+
+/// JS documentation of the native allocations table:
+///
+/// ```ignore
+/// /**
+///  * This variant is the original version of the table, before the memory address
+///  * and threadId were added.
+///  */
+/// export type UnbalancedNativeAllocationsTable = {|
+///   time: Milliseconds[],
+///   // "weight" is used here rather than "bytes", so that this type will match the
+///   // SamplesLikeTableShape.
+///   weight: Bytes[],
+///   weightType: 'bytes',
+///   stack: Array<IndexIntoStackTable | null>,
+///   length: number,
+/// |};
+///
+/// /**
+///  * The memory address and thread ID were added later.
+///  */
+/// export type BalancedNativeAllocationsTable = {|
+///   ...UnbalancedNativeAllocationsTable,
+///   memoryAddress: number[],
+///   threadId: number[],
+/// |};
+/// ```
+///
+/// In this crate we always create a `BalancedNativeAllocationsTable`. We require
+/// a memory address for each allocation / deallocation sample.
+#[derive(Debug, Clone, Default)]
+pub struct NativeAllocationsTable {
+    /// The timstamps for each sample
+    time: Vec<Timestamp>,
+    /// The stack index for each sample
+    stack: Vec<Option<usize>>,
+    /// The size in bytes (positive for allocations, negative for deallocations) for each sample
+    allocation_size: Vec<i64>,
+    /// The memory address of the allocation for each sample
+    allocation_address: Vec<u64>,
+}
+
+impl NativeAllocationsTable {
+    /// Add a sample to the [`NativeAllocations`] table.
+    pub fn add_sample(
+        &mut self,
+        timestamp: Timestamp,
+        stack_index: Option<usize>,
+        allocation_address: u64,
+        allocation_size: i64,
+    ) {
+        self.time.push(timestamp);
+        self.stack.push(stack_index);
+        self.allocation_address.push(allocation_address);
+        self.allocation_size.push(allocation_size);
+    }
+}
+
+impl Serialize for NativeAllocationsTable {
+    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        let len = self.time.len();
+        let mut map = serializer.serialize_map(None)?;
+        map.serialize_entry("time", &self.time)?;
+        map.serialize_entry("weight", &self.allocation_size)?;
+        map.serialize_entry("weightType", &WeightType::Bytes)?;
+        map.serialize_entry("stack", &self.stack)?;
+        map.serialize_entry("memoryAddress", &self.allocation_address)?;
+
+        // The threadId column is currently unused by the Firefox Profiler.
+        // Fill the column with zeros because the type definitions require it to be a number.
+        // A better alternative would be to use thread indexes or the threads' string TIDs.
+        map.serialize_entry("threadId", &SerializableSingleValueColumn(0, len))?;
+
+        map.serialize_entry("length", &len)?;
+        map.end()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use assert_json_diff::assert_json_eq;
+    use serde_json::json;
+
+    use super::*;
+
+    #[test]
+    fn test_serialize_native_allocations() {
+        // example of `nativeAllocations`:
+        //
+        // "nativeAllocations": {
+        //     "time": [
+        //         274364.1082197344,
+        //         274364.17226073437,
+        //         274364.2063027344,
+        //         274364.2229277344,
+        //         274364.44117773435,
+        //         274366.4713027344,
+        //         274366.48871973436,
+        //         274366.6601777344,
+        //         274366.6705107344
+        //     ],
+        //     "weight": [
+        //         4096,
+        //         -4096,
+        //         4096,
+        //         -4096,
+        //         147456,
+        //         4096,
+        //         -4096,
+        //         96,
+        //         -96
+        //     ],
+        //     "weightType": "bytes",
+        //     "stack": [
+        //         71,
+        //         88,
+        //         119,
+        //         138,
+        //         null,
+        //         171,
+        //         190,
+        //         210,
+        //         214
+        //     ],
+        //     "memoryAddress": [
+        //         4388749312,
+        //         4388749312,
+        //         4388749312,
+        //         4388749312,
+        //         4376330240,
+        //         4388749312,
+        //         4388749312,
+        //         4377576256,
+        //         4377576256
+        //     ],
+        //     "threadId": [
+        //         0,
+        //         0,
+        //         0,
+        //         0,
+        //         0,
+        //         0,
+        //         0,
+        //         0,
+        //         0
+        //     ],
+        //     "length": 9
+        // },
+
+        let mut native_allocations_table = NativeAllocationsTable::default();
+        native_allocations_table.add_sample(
+            Timestamp::from_millis_since_reference(274_363.248_375),
+            None,
+            5969772544,
+            147456,
+        );
+
+        assert_json_eq!(
+            native_allocations_table,
+            json!({
+              "time": [
+                274363.248375
+              ],
+              "weight": [
+                147456
+              ],
+              "weightType": "bytes",
+              "stack": [
+                null
+              ],
+              "memoryAddress": [
+                5969772544u64
+              ],
+              "threadId": [
+                0
+              ],
+              "length": 1
+            })
+        );
+    }
+}

data/ext/cargo-vendor/fxprof-processed-profile-0.8.1/src/serialization_helpers.rs

@@ -0,0 +1,41 @@
+use serde::ser::{Serialize, SerializeSeq, Serializer};
+
+use crate::Timestamp;
+
+pub struct SerializableSingleValueColumn<T: Serialize>(pub T, pub usize);
+
+impl<T: Serialize> Serialize for SerializableSingleValueColumn<T> {
+    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        let mut seq = serializer.serialize_seq(Some(self.1))?;
+        for _ in 0..self.1 {
+            seq.serialize_element(&self.0)?;
+        }
+        seq.end()
+    }
+}
+
+pub struct SerializableOptionalTimestampColumn<'a>(pub &'a [Option<Timestamp>]);
+
+impl Serialize for SerializableOptionalTimestampColumn<'_> {
+    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        let mut seq = serializer.serialize_seq(Some(self.0.len()))?;
+        for timestamp in self.0 {
+            match timestamp {
+                Some(timestamp) => seq.serialize_element(&timestamp)?,
+                None => seq.serialize_element(&0.0)?,
+            }
+        }
+        seq.end()
+    }
+}
+
+pub struct SliceWithPermutation<'a, T: Serialize>(pub &'a [T], pub &'a [usize]);
+
+impl<T: Serialize> Serialize for SliceWithPermutation<'_, T> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.collect_seq(self.1.iter().map(|i| &self.0[*i]))
+    }
+}

data/ext/cargo-vendor/fxprof-processed-profile-0.8.1/src/stack_table.rs

@@ -0,0 +1,79 @@
+use serde::ser::{Serialize, SerializeMap, Serializer};
+
+use crate::fast_hash_map::FastHashMap;
+
+/// The stack table stores the tree of stack nodes of a thread. The shape of the tree is encoded in
+/// the prefix column: Root stack nodes have null as their prefix, and every non-root stack has the
+/// stack index of its "caller" / "parent" as its prefix. Every stack node also has a frame and a
+/// category. A "call stack" is a list of frames. Every stack index in the stack table represents
+/// such a call stack; the "list of frames" is obtained by walking the path in the tree from the
+/// root to the given stack node.
+///
+/// Stacks are used in the thread's samples; each sample refers to a stack index. Stacks can be
+/// shared between samples.
+///
+/// With this representation, every sample only needs to store a single integer to identify the
+/// sample's stack. We take advantage of the fact that many call stacks in the profile have a
+/// shared prefix; storing these stacks as a tree saves a lot of space compared to storing them as
+/// actual lists of frames.
+///
+/// The category of a stack node is always non-null and is derived from a stack's frame and its
+/// prefix. Frames can have null categories, stacks cannot. If a stack's frame has a null category,
+/// the stack inherits the category of its prefix stack. Root stacks whose frame has a null stack
+/// have their category set to the "default category". (The default category is currently defined
+/// as the category in the profile's category list whose color is "grey", and such a category is
+/// required to be present.)
+///
+/// You could argue that the stack table's category column is derived data and as such doesn't need
+/// to be stored in the profile itself. This is true, but storing this information in the stack
+/// table makes it a lot easier to carry it through various transforms that we apply to threads.
+/// For example, here's a case where a stack's category is not recoverable from any other
+/// information in the transformed thread:
+///
+/// In the call path
+///   someJSFunction [JS] -> Node.insertBefore [DOM] -> nsAttrAndChildArray::InsertChildAt,
+///
+/// the stack node for nsAttrAndChildArray::InsertChildAt should inherit the category DOM from its
+/// "Node.insertBefore" prefix stack. And it should keep the DOM category even if you apply the
+/// "Merge node into calling function" transform to Node.insertBefore. This transform removes the
+/// stack node "Node.insertBefore" from the stackTable, so the information about the DOM category
+/// would be lost if it wasn't inherited into the nsAttrAndChildArray::InsertChildAt stack before
+/// transforms are applied.
+#[derive(Debug, Clone, Default)]
+pub struct StackTable {
+    stack_prefixes: Vec<Option<usize>>,
+    stack_frames: Vec<usize>,
+
+    // (parent stack, frame_index) -> stack index
+    index: FastHashMap<(Option<usize>, usize), usize>,
+}
+
+impl StackTable {
+    pub fn new() -> Self {
+        Default::default()
+    }
+
+    pub fn index_for_stack(&mut self, prefix: Option<usize>, frame: usize) -> usize {
+        match self.index.get(&(prefix, frame)) {
+            Some(stack) => *stack,
+            None => {
+                let stack = self.stack_prefixes.len();
+                self.stack_prefixes.push(prefix);
+                self.stack_frames.push(frame);
+                self.index.insert((prefix, frame), stack);
+                stack
+            }
+        }
+    }
+}
+
+impl Serialize for StackTable {
+    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        let len = self.stack_prefixes.len();
+        let mut map = serializer.serialize_map(Some(3))?;
+        map.serialize_entry("length", &len)?;
+        map.serialize_entry("prefix", &self.stack_prefixes)?;
+        map.serialize_entry("frame", &self.stack_frames)?;
+        map.end()
+    }
+}

data/ext/cargo-vendor/fxprof-processed-profile-0.8.1/src/string_table.rs

@@ -0,0 +1,66 @@
+use std::ops::Deref;
+
+use serde::ser::{Serialize, Serializer};
+
+use crate::fast_hash_map::FastHashMap;
+
+#[derive(Debug, Clone, Copy, PartialOrd, Ord, PartialEq, Eq, Hash)]
+pub struct StringIndex(u32);
+
+#[derive(Debug, Clone, Default)]
+pub struct StringTable {
+    strings: Vec<String>,
+    index: FastHashMap<String, StringIndex>,
+}
+
+impl StringTable {
+    pub fn index_for_string(&mut self, s: &str) -> StringIndex {
+        match self.index.get(s) {
+            Some(string_index) => *string_index,
+            None => {
+                let string_index = StringIndex(self.strings.len() as u32);
+                self.strings.push(s.to_string());
+                self.index.insert(s.to_string(), string_index);
+                string_index
+            }
+        }
+    }
+
+    pub fn get_string(&self, index: StringIndex) -> Option<&str> {
+        self.strings.get(index.0 as usize).map(Deref::deref)
+    }
+}
+
+impl Serialize for StringTable {
+    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        self.strings.serialize(serializer)
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialOrd, Ord, PartialEq, Eq, Hash)]
+pub struct GlobalStringIndex(pub(crate) StringIndex);
+
+#[derive(Debug, Clone, Default)]
+pub struct GlobalStringTable {
+    table: StringTable,
+}
+
+impl GlobalStringTable {
+    pub fn new() -> Self {
+        Default::default()
+    }
+
+    pub fn index_for_string(&mut self, s: &str) -> GlobalStringIndex {
+        GlobalStringIndex(self.table.index_for_string(s))
+    }
+
+    pub fn get_string(&self, index: GlobalStringIndex) -> Option<&str> {
+        self.table.get_string(index.0)
+    }
+}
+
+impl Serialize for StringIndex {
+    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        serializer.serialize_u32(self.0)
+    }
+}