Improve the markers API in fxprof-processed-profile (#712)

See the diff of
`fxprof-processed-profile/tests/integration_tests/main.rs` for the
before/after.

Author: mstange

fxprof-processed-profile/src/lib.rs

@@ -81,10 +81,11 @@ pub use global_lib_table::LibraryHandle;
 pub use lib_mappings::LibMappings;
 pub use library_info::{LibraryInfo, Symbol, SymbolTable};
 pub use markers::{
-    GraphColor, Marker, MarkerFieldFlags, MarkerFieldFormat, MarkerFieldFormatKind,
-    MarkerGraphType, MarkerHandle, MarkerLocations, MarkerTiming, MarkerTypeHandle,
-    RuntimeSchemaMarkerField, RuntimeSchemaMarkerGraph, RuntimeSchemaMarkerSchema,
-    StaticSchemaMarker, StaticSchemaMarkerField, StaticSchemaMarkerGraph,
+    DynamicSchemaMarker, DynamicSchemaMarkerField, DynamicSchemaMarkerFieldFormat,
+    DynamicSchemaMarkerGraph, DynamicSchemaMarkerSchema, FlowId, GraphColor, Marker, MarkerField,
+    MarkerFieldKind, MarkerFlowFieldFormat, MarkerGraph, MarkerGraphType, MarkerHandle,
+    MarkerLocations, MarkerNumberFieldFormat, MarkerStringFieldFormat, MarkerTiming,
+    MarkerTypeHandle, Schema,
 };
 pub use native_symbols::NativeSymbolHandle;
 pub use process::ThreadHandle;

fxprof-processed-profile/src/marker_table.rs

@@ -1,11 +1,11 @@
 use serde::ser::{Serialize, SerializeMap, SerializeSeq, Serializer};
 
-use crate::markers::{InternalMarkerSchema, MarkerFieldFormatKind};
+use crate::markers::{InternalMarkerSchema, MarkerFieldValueConsumer};
 use crate::serialization_helpers::SerializableOptionalTimestampColumn;
 use crate::string_table::{ProfileStringTable, StringHandle};
 use crate::{
-    CategoryHandle, Marker, MarkerFieldFormat, MarkerHandle, MarkerTiming, MarkerTypeHandle,
-    Timestamp,
+    CategoryHandle, DynamicSchemaMarker, DynamicSchemaMarkerFieldFormat, MarkerHandle,
+    MarkerStringFieldFormat, MarkerTiming, MarkerTypeHandle, Timestamp,
 };
 
 #[derive(Debug, Clone, Default)]
@@ -53,7 +53,7 @@ impl MarkerTable {
     }
 
     #[allow(clippy::too_many_arguments)]
-    pub fn add_marker<T: Marker>(
+    pub fn add_marker<T: DynamicSchemaMarker>(
         &mut self,
         string_table: &mut ProfileStringTable,
         name_string_index: StringHandle,
@@ -75,25 +75,20 @@ impl MarkerTable {
         self.marker_phases.push(phase);
         self.marker_type_handles.push(marker_type_handle);
         self.marker_stacks.push(None);
-        for (field_index, field) in schema.fields().iter().enumerate() {
-            match field.format.kind() {
-                MarkerFieldFormatKind::String => {
-                    let string_index = marker.string_field_value(field_index as u32);
-                    self.marker_field_string_values.push(string_index);
-                }
-                MarkerFieldFormatKind::Number => {
-                    let number_value = marker.number_field_value(field_index as u32);
-                    self.marker_field_number_values.push(number_value)
-                }
-                MarkerFieldFormatKind::Flow => {
-                    let flow_value = marker.flow_field_value(field_index as u32);
-                    // Convert flow ID to hex string and store as StringHandle
-                    let hex_string = format!("{flow_value:x}");
-                    let flow_string_handle = string_table.index_for_string(&hex_string);
-                    self.marker_field_flow_values.push(flow_string_handle);
-                }
-            }
-        }
+
+        let MarkerTable {
+            marker_field_string_values,
+            marker_field_number_values,
+            marker_field_flow_values,
+            ..
+        } = self;
+
+        marker.push_field_values(&mut MarkerTableFieldValueConsumer {
+            marker_field_string_values,
+            marker_field_number_values,
+            marker_field_flow_values,
+            string_table,
+        });
 
         MarkerHandle(self.marker_categories.len() - 1)
     }
@@ -124,6 +119,30 @@ impl MarkerTable {
     }
 }
 
+struct MarkerTableFieldValueConsumer<'a> {
+    marker_field_string_values: &'a mut Vec<StringHandle>,
+    marker_field_number_values: &'a mut Vec<f64>,
+    marker_field_flow_values: &'a mut Vec<StringHandle>,
+    string_table: &'a mut ProfileStringTable,
+}
+
+impl<'a> MarkerFieldValueConsumer for MarkerTableFieldValueConsumer<'a> {
+    fn consume_string_field(&mut self, string_handle: StringHandle) {
+        self.marker_field_string_values.push(string_handle);
+    }
+
+    fn consume_number_field(&mut self, number: f64) {
+        self.marker_field_number_values.push(number);
+    }
+
+    fn consume_flow_field(&mut self, flow: u64) {
+        // Convert flow ID to hex string and store as StringHandle
+        let hex_string = format!("{flow:x}");
+        let flow_string_handle = self.string_table.index_for_string(&hex_string);
+        self.marker_field_flow_values.push(flow_string_handle);
+    }
+}
+
 struct SerializableMarkerTable<'a> {
     marker_table: &'a MarkerTable,
     string_table: &'a ProfileStringTable,
@@ -215,23 +234,23 @@ impl Serialize for SerializableMarkerDataElement<'_> {
             map.serialize_entry("cause", &SerializableMarkerCause(*stack_index))?;
         }
         for field in schema.fields() {
-            match field.format.kind() {
-                MarkerFieldFormatKind::String => {
+            match &field.format {
+                DynamicSchemaMarkerFieldFormat::String(format) => {
                     let value;
                     (value, string_fields) = string_fields.split_first().unwrap();
-                    if field.format == MarkerFieldFormat::String {
+                    if *format == MarkerStringFieldFormat::String {
                         map.serialize_entry(&field.key, value)?;
                     } else {
                         let str_val = string_table.get_string(*value);
                         map.serialize_entry(&field.key, str_val)?;
                     }
                 }
-                MarkerFieldFormatKind::Number => {
+                DynamicSchemaMarkerFieldFormat::Number(_) => {
                     let value;
                     (value, number_fields) = number_fields.split_first().unwrap();
                     map.serialize_entry(&field.key, value)?;
                 }
-                MarkerFieldFormatKind::Flow => {
+                DynamicSchemaMarkerFieldFormat::Flow(_) => {
                     let value;
                     (value, flow_fields) = flow_fields.split_first().unwrap();
                     map.serialize_entry(&field.key, value)?;