Framework Time Measurement

crates/code_generation/src/cyclers.rs

@@ -39,7 +39,7 @@ pub fn generate_cyclers(cyclers: &Cyclers) -> TokenStream {
 fn generate_module(cycler: &Cycler, cyclers: &Cyclers) -> TokenStream {
     let module_name = format_ident!("{}", cycler.name.to_case(Case::Snake));
     let cycler_instance = generate_cycler_instance(cycler);
-    let database_struct = generate_database_struct();
+    let database_struct = generate_database_struct(cycler);
     let cycler_struct = generate_struct(cycler, cyclers);
     let cycler_implementation = generate_implementation(cycler, cyclers);
 
@@ -70,12 +70,15 @@ fn generate_cycler_instance(cycler: &Cycler) -> TokenStream {
     }
 }
 
-fn generate_database_struct() -> TokenStream {
+fn generate_database_struct(cycler: &Cycler) -> TokenStream {
+    let cycler_name = format_ident!("{}", cycler.name.to_case(Case::Snake));
+
     quote! {
         #[derive(Default, serde::Deserialize, serde::Serialize, serialize_hierarchy::SerializeHierarchy)]
         pub(crate) struct Database {
             pub main_outputs: MainOutputs,
             pub additional_outputs: AdditionalOutputs,
+            pub cycle_timings: crate::structs::#cycler_name::CycleTimings,
         }
     }
 }
@@ -656,6 +659,7 @@ fn generate_node_execution(
             }
             #[allow(clippy::needless_else)]
             if #are_required_inputs_some {
+                let cycle_start = std::time::SystemTime::now();
                 let main_outputs = {
                     let _task = ittapi::Task::begin(&itt_domain, #node_name);
                     self.#node_member.cycle(
@@ -665,6 +669,9 @@ fn generate_node_execution(
                     )
                     .wrap_err(#cycle_error_message)?
                 };
+                let cycle_duration = cycle_start.elapsed().expect("time ran backwards");
+                own_database_reference.cycle_timings.#node_member = cycle_duration;
+
                 #database_updates
             }
             else {

crates/code_generation/src/structs.rs

@@ -36,12 +36,18 @@ pub fn generate_structs(structs: &Structs) -> TokenStream {
                 format_ident!("CyclerState"),
                 &derives,
             );
+            let cycle_times = hierarchy_to_token_stream(
+                &cycler_structs.cycle_times,
+                format_ident!("CycleTimings"),
+                &derives,
+            );
 
             quote! {
                 pub mod #cycler_module_identifier {
                     #main_outputs
                     #additional_outputs
                     #cycler_state
+                    #cycle_times
                 }
             }
         });

crates/source_analyzer/src/structs.rs

@@ -1,6 +1,7 @@
 use std::{collections::BTreeMap, iter::once};
 
-use quote::format_ident;
+use convert_case::{Case, Casing};
+use quote::{format_ident, quote};
 use syn::{
     punctuated::Punctuated, AngleBracketedGenericArguments, GenericArgument, PathArguments, Type,
     TypePath,
@@ -36,6 +37,15 @@ impl Structs {
             let cycler_structs = structs.cyclers.entry(cycler.name.clone()).or_default();
 
             for node in cycler.iter_nodes() {
+                cycler_structs.cycle_times.insert([
+                    InsertionRule::InsertField {
+                        name: node.name.to_case(Case::Snake),
+                    },
+                    InsertionRule::AppendDataType {
+                        data_type: Type::Verbatim(quote! { std::time::Duration }),
+                    },
+                ])?;
+
                 for field in node.contexts.main_outputs.iter() {
                     add_main_outputs(field, cycler_structs);
                 }
@@ -133,6 +143,7 @@ pub struct CyclerStructs {
     pub main_outputs: StructHierarchy,
     pub additional_outputs: StructHierarchy,
     pub cycler_state: StructHierarchy,
+    pub cycle_times: StructHierarchy,
 }
 
 fn path_to_insertion_rules<'path>(